cpp-lazy-stream/include/stream/streams/filter.hpp

#pragma once

namespace stream { namespace detail {
  template <typename T> class filter_iterator {
  public:
    filter_iterator(std::function<bool(T const &)> f, iterator<T> && impl,
                    iterator<T> && end)
        : pred_(f), impl_(std::forward<iterator<T>>(impl)),
          end_(std::forward<iterator<T>>(end)) {
      advance();
    }

    T operator*() { return mem_; }

    filter_iterator & operator++() {
      ++impl_;
      advance();
      return *this;
    }

    bool operator==(filter_iterator const & rhs) const {
      return impl_ == rhs.impl_;
    }
    
  private:
    void advance() {
      while (impl_ != end_ && !pred_(mem_ = *impl_)) {
        ++impl_;
      }
    }

    std::function<bool(T const &)> pred_;
    ref_or_val<T> mem_; // To avoid re-calcs, we store this
    iterator<T> impl_, end_;
  };

  template <typename T> class filter_stream {
  public:
    template <typename F>
    filter_stream(F && func, stream_base<T> const & sb)
        : pred_(func), source_(sb) {}

    iterator<T> begin() {
      return {filter_iterator<T>{pred_, source_.begin(), source_.end()}};
    }

    iterator<T> end() {
      return {filter_iterator<T>{pred_, source_.end(), source_.end()}};
    }

  private:
    std::function<bool(T const &)> pred_;
    stream_base<T> source_;
  };

  template <typename T>
  template <typename F>
  auto stream_base<T>::filter(F && pred) && -> stream_base<T> {
    return std::make_shared<filter_stream<T>>(pred, std::move(*this));
  }

  template <typename T>
  template <typename F>
  auto stream_base<T>::filter(F && pred) const & -> stream_base<T> {
    return std::make_shared<filter_stream<T>>(pred, *this);
  }
}}