cpp-lazy-stream/streams/source.hpp

#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_;
    };
  }
  
  template <typename C>
  detail::stream_base<detail::source::reference<C>> make_stream(C && cont) {
    return detail::source_stream<C>(cont);
  }
  
  template <typename T>
  detail::stream_base<T&> make_stream(T * ptr) {
    return detail::range_stream<T*, T>(ptr, ptr+1);
  }

  template <typename It>
  detail::stream_base<typename It::reference> make_stream(It begin, It end) {
    return detail::range_stream<It>(begin, end);
  }
}