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

#pragma once

#include <iterator/proxy.h>

namespace stream::detail {
  template <typename T, typename R>
  class map_iterator
      : public ::iterator::proxy<iterator<T>, map_iterator<T, R>> {
  public:
    using projection_t = std::function<R(T const &)>;
    using super_t = ::iterator::proxy<iterator<T>, map_iterator<T, R>>;

  public:
    map_iterator(projection_t proj, iterator<T> && impl)
        : proj_(std::move(proj)), super_t(std::move(impl)) {}

    R dereference() const { return proj_(super_t::dereference()); }

  private:
    std::function<R(T const &)> proj_;
  };

  template <typename T, typename R> class map_stream {
  public:
    template <typename F>
    map_stream(F && func, stream_base<T> const & sb)
        : fun_(func), source_(sb) {}

    iterator<R> begin() { return {map_iterator<T, R>{fun_, source_.begin()}}; }

    iterator<R> end() { return {map_iterator<T, R>{fun_, source_.end()}}; }

  private:
    std::function<R(T const &)> fun_;
    stream_base<T> source_;
  };

  template <typename T>
  template <typename F>
  stream_base<traits::mapped_t<T, F>> stream_base<T>::map(F && func) && {
    return std::make_shared<map_stream<T, traits::mapped_t<T, F>>>(
        func, std::move(*this));
  }

  template <typename T>
  template <typename F>
  stream_base<traits::mapped_t<T, F>> stream_base<T>::map(F && func) const & {
    return std::make_shared<map_stream<T, traits::mapped_t<T, F>>>(func, *this);
  }
}