cpp-lazy-stream/streams/source.hpp

#pragma once

namespace stream {
  namespace detail {
    namespace source {
      template <typename Iter>
      class iterator : public iterator_impl<typename std::iterator_traits<Iter>::reference> {
      public:
        using value_type = typename std::iterator_traits<Iter>::reference;
        typedef iterator_impl<value_type> super;
        explicit iterator(Iter it) : impl_(it) {}
        ~iterator() {}
        value_type operator*() override { 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 stream_impl<source::reference<C>> {
    public:
      typedef source::reference<C> reference;
      typedef decltype(std::declval<C>().begin()) _iterator;
      
      explicit source_stream(C && cont) : source_(std::forward<C>(cont)) {}
      ~source_stream() override {}
      iterator<reference> begin() override { return {new source::iterator<_iterator>{source_.begin()}}; }
      iterator<reference> end() override { return {new source::iterator<_iterator>{source_.end()}}; }
    private:
      C source_;
    };
    
    template <typename It, typename V = typename It::value_type>
    class range_stream : public stream_impl<V &> {
    public:
      typedef V & reference;
      
      explicit range_stream(It b, It e) : begin_(b), end_(e) {}
      ~range_stream() override {}
      iterator<reference> begin() override { return {new source::iterator<It>{begin_}}; }
      iterator<reference> end() override { return {new source::iterator<It>{end_}}; }
    private:
      It begin_, end_;
    };
  }
  
  template <typename C>
  detail::stream_base<detail::source::reference<C>> make_stream(C && cont) {
    return {std::make_shared<detail::source_stream<C>>(cont)};
  }
  
  template <typename T>
  detail::stream_base<T&> make_stream(T * ptr) {
    return {std::make_shared<detail::range_stream<T*, T>>(ptr, ptr+1)};
  }

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