iterators.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_CORE_NG_BASE_ITERATORS_H_INCLUDED
#define ZYPP_CORE_NG_BASE_ITERATORS_H_INCLUDED
 
#include <iterator>
#include <utility>
 
namespace zyppng {

  template<class Pred, class Base>
  class FilterIterator {
  public:
    using iterator_category = std::forward_iterator_tag;
    using value_type        = typename std::iterator_traits<Base>::value_type;
    using difference_type   = typename std::iterator_traits<Base>::difference_type;
    using pointer           = typename std::iterator_traits<Base>::pointer;
    using reference         = typename std::iterator_traits<Base>::reference;

    FilterIterator() = default;

    FilterIterator(Pred p, Base it, Base end) 
      : _pred(std::move(p)), _it(std::move(it)), _end(std::move(end)) 
    {
      satisfy_predicate();
    }

    reference operator*() const { return *_it; }
    
    pointer operator->() const { return &(*_it); }

    FilterIterator& operator++() {
      ++_it;
      satisfy_predicate();
      return *this;
    }

    FilterIterator operator++(int) {
      FilterIterator tmp = *this;
      ++(*this);
      return tmp;
    }

    bool operator==(const FilterIterator& other) const {
      return _it == other._it;
    }

    bool operator!=(const FilterIterator& other) const {
      return !(*this == other);
    }

    Base const & base() const { return _it; }
 
  private:
    void satisfy_predicate() {
      while (_it != _end && !_pred(*_it)) {
        ++_it;
      }
    }
 
    Pred _pred;
    Base _it;
    Base _end;
  };

  template<class Pred, class Base>
  FilterIterator<Pred, Base> make_filter_iterator(Pred p, Base it, Base end) {
    return FilterIterator<Pred, Base>(std::move(p), std::move(it), std::move(end));
  }
 
} // namespace zyppng
 
#endif