FilterIterator.hh

Go to the documentation of this file.

#ifndef FilteredConfigIterator_HH
#define FilteredConfigIterator_HH
 
#include <iterator>
 
#include "casm/global/definitions.hh"
 
namespace CASM {
 
template <typename IteratorType>
class FilterIterator;
 
template <typename IteratorType>
void swap(FilterIterator<IteratorType> &a, FilterIterator<IteratorType> &b);
 
template <typename IteratorType>
class FilterIterator : std::iterator<std::input_iterator_tag,
                                     typename IteratorType::value_type> {
 public:
  using pointer = typename IteratorType::pointer;
  using reference = typename IteratorType::reference;
  using DataObject = typename IteratorType::value_type;
 
  FilterIterator(){};
 
  FilterIterator(IteratorType const &_begin, IteratorType const &_end,
                 std::function<bool(reference)> _filter)
      : m_it(_begin), m_end(_end) {
    while (m_it != m_end && !m_filter(*m_it)) {
      ++m_it;
    }
  }
 
  FilterIterator(IteratorType const &_end) : m_it(_end), m_end(_end) {}
 
  reference operator*() const { return *m_it; }
 
  pointer operator->() const { return m_it.operator->(); }
 
  bool operator==(const FilterIterator &RHS) const { return m_it == RHS.m_it; }
 
  bool operator!=(const FilterIterator &RHS) const { return m_it != RHS.m_it; }
 
  FilterIterator &operator++() {
    ++m_it;
    while (m_it != m_end && !m_filter(*m_it)) {
      ++m_it;
    }
    return *this;
  }
 
  FilterIterator operator++(int) {
    FilterIterator<IteratorType> t_it(*this);
    operator++();
    return t_it;
  }
 
  friend void swap<>(FilterIterator &a, FilterIterator &b);
 
 private:
  IteratorType m_it, m_end;
  std::function<bool(reference)> m_filter;
};
 
template <typename IteratorType>
void swap(FilterIterator<IteratorType> &a, FilterIterator<IteratorType> &b) {
  using std::swap;
 
  swap(a.m_it, b.m_it);
  swap(a.m_end, b.m_end);
  swap(a.m_filter, b.m_filter);
}
 
template <typename IteratorType, typename DataObject>
FilterIterator<IteratorType> filter_begin(
    IteratorType const &it, IteratorType const &it_end,
    std::function<bool(typename FilterIterator<IteratorType>::reference)>
        filter_function) {
  return FilterIterator<IteratorType>(it, it_end, filter_function);
}
 
template <typename IteratorType>
FilterIterator<IteratorType> filter_end(IteratorType const &it_end) {
  return FilterIterator<IteratorType>(it_end);
}
 
}  // namespace CASM
#endif