cpp-lazy-stream/streams/join.hpp

#pragma once

namespace stream { namespace detail {
  namespace join {
    template <typename C>
    class iterator : public iterator_impl<typename C::value_type> {
    public:
      typedef iterator_impl<typename C::value_type> super;
      iterator(::stream::iterator<C>&& f, ::stream::iterator<C>&& l)
      : start_(std::forward<::stream::iterator<C>>(f))
      , finish_(std::forward<::stream::iterator<C>>(l))
      {
        if (start_ != finish_) {
          mem_ = *(start_);
          curr_ = mem_.begin();
          end_ = mem_.end();
          advance();
        }
      }
      ~iterator() {}
      typename C::value_type operator*() override { return *curr_; }
      
      super& operator++() override {
        ++curr_;
        advance();
        return *this;
      }
      
      DELEGATE_ITERATOR_IMPL_BASE(start_)
    private:
      void advance() {
        while (curr_ == end_ && start_ != finish_) {
          if ( ++start_ == finish_ ) { break; }
          mem_ = *start_;
          curr_ = mem_.begin();
          end_ = mem_.end();
        }
      }
      ::stream::iterator<C> start_, finish_;
      C mem_;
      typename C::iterator curr_, end_;
    };
  }
  
  template <typename C>
  class join_stream : public stream_impl<typename C::value_type> {
  public:
    using T = typename C::value_type;
    explicit join_stream(stream_base<C> const& sb) : source_(sb) {}
    ~join_stream() override {}
    
    ::stream::iterator<T> begin() override {
      return {new join::iterator<C>{source_.begin(), source_.end()}};
    }
    ::stream::iterator<T> end() override {
      return {new join::iterator<C>{source_.end(), source_.end()}};
    }
  private:
    stream_base<C> source_;
  };
  
  template <typename C>
  auto make_join(stream_base<C> const& sb) -> stream_base<typename C::value_type>  {
    using T = typename C::value_type;
    using impl_t = join_stream<C>;
    return {std::make_shared<impl_t>(sb)};
  }
  
  template <typename T>
  template <typename F>
  auto stream_base<T>::flatmap(F&& func) const -> stream_base<flatmap_f<F>>  {
    return make_join((*this).map(func));
  }
} }