cpp-lazy-stream/include/stream/source.hpp

#pragma once

#include <iterator>

namespace stream::detail {
template <typename C> class source_stream {
public:
  explicit source_stream(C && cont) : source_(std::forward<C>(cont)) {}

  auto begin() { return iterator(source_.begin()); }
  auto end() { return iterator(source_.end()); }

private:
  C source_;
};

template <typename It> class range_stream {
public:
  explicit range_stream(It b, It e) : begin_(b), end_(e) {}

  auto begin() { return iterator(begin_); }
  auto end() { return iterator(end_); }

private:
  It begin_, end_;
};
}

namespace stream {
/**
 * Construct a stream out of the given container. If C && is an rvalue
 * reference, the returned object will take ownership of cont. Otherwise, we
 * capture cont by reference to maximise performance.
 */
template <typename C>
auto of(C && cont) -> detail::stream_base<decltype(*cont.begin())> {
  return std::make_shared<detail::source_stream<C>>(std::forward<C>(cont));
}

template <typename T> detail::stream_base<T &> empty() {
  return std::make_shared<detail::range_stream<T *>>(nullptr, nullptr);
}

/**
 * Construct a single element stream containing the pointer given
 */
template <typename T> detail::stream_base<T &> of(T * ptr) {
  return std::make_shared<detail::range_stream<T *>>(ptr, ptr + 1);
}

/**
 * Construct a stream from input iterators representing the start and end
 * Requirements: It must be an iterator type that provides the trait
 * 'reference'
 */
template <typename It>
detail::stream_base<typename It::reference> of(It begin, It end) {
  return std::make_shared<detail::range_stream<It>>(begin, end);
}

/**
 * Construct a stream given certain start and end bounds.
 * e.g. stream::make_range_stream(0, 10)
 */
template <typename T> detail::stream_base<T &> range(T start, T const & end) {
  std::vector<T> vec;
  vec.reserve(end - start);
  while (start < end) {
    vec.emplace_back(start++);
  }
  return make_stream(std::move(vec));
}

/**
 * Construct a stream given certain start and end bounds, as well as an
 * increment amount. e.g. stream::make_range_stream(0, 10, 2)
 */
template <typename T>
detail::stream_base<T &> range(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));
}
}