#pragma once

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_iterator<_iterator>{source_.begin()}};
    }
    iterator<reference> end() {
      return {source_iterator<_iterator>{source_.end()}};
    }

  private:
    C source_;
  };

  template <typename It, typename V = typename It::value_type>
  class range_stream {
  public:
    typedef V & reference;

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

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

  private:
    It begin_, end_;
  };
}}