cpp-lazy-stream/include/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 std::make_shared<detail::source_stream<C>>(std::forward<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);
  }

  template <typename T>
  detail::stream_base<T &> make_range_stream(T start, T const & end) {
    std::vector<T> vec;
    vec.reserve(end - start);
    while (end < start) {
      vec.emplace_back(start++);
    }
    return make_stream(std::move(vec));
  }

  template <typename T>
  detail::stream_base<T &> make_range_stream(T start, T const & end,
                                             T const & increment) {
    int elems{(end - start) / increment};
    if (elems < 0 || end == start) { return {}; }
    std::vector<T> vec{start};
    vec.reserve(elems + 1);
    while (elems-- > 0) {
      vec.emplace_back(start += increment);
    }
    return make_stream(std::move(vec));
  }
}