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

#pragma once

#include <iterator>

namespace stream { namespace detail {
  template <typename Iter> class source_iterator {
  public:
    using value_type = typename std::iterator_traits<Iter>::reference;
    explicit source_iterator(Iter it) : impl_(it) {}

    value_type operator*() { return *impl_; }
    source_iterator & operator++() {
      ++impl_;
      return *this;
    }
    bool operator==(source_iterator const & rhs) const {
      return impl_ == rhs.impl_;
    }

  private:
    Iter impl_;
  };

  template <typename C> class source_stream {
  public:
    typedef decltype(std::declval<C>().begin()) _iterator;
    typedef decltype(*std::declval<_iterator>()) reference;

    explicit source_stream(C && cont) : source_(std::forward<C>(cont)) {}

    iterator<reference> begin() { return {source_.begin()}; }
    iterator<reference> end() { return {source_.end()}; }

  private:
    C source_;
  };

  template <typename It, typename R = typename It::reference>
  class range_stream {
  public:
    using reference = R;

    explicit range_stream(It b, It e) : begin_(b), end_(e) {}

    iterator<reference> begin() { return {begin_}; }
    iterator<reference> end() { return {end_}; }

  private:
    It begin_, end_;
  };
}}