#pragma once

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

      value_type operator*() { return *impl_; }
      DELEGATE_ITERATOR_IMPL(impl_)
    private:
      Iter impl_;
    };

    template <typename C>
    using reference = decltype(*std::declval<C>().begin());
  }

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

    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_;
  };
}}