cpp-useful-iterators/include/iterator/join_iterator.hpp

//
//  join_iterator.hpp
//  iterator
//
//  Created by Sam Jaffe on 2/7/17.
//

#pragma once

#include <iterator>
#include <utility>

#include <iterator/end_aware_iterator.hpp>
#include <iterator/facade.h>
#include <iterator/iterator_fwd.hpp>

namespace iterator {
template <typename MetaIterator>
class joining_iterator : public facade<joining_iterator<MetaIterator>> {
public:
  using join_iter = MetaIterator;
  using joinable_type = typename join_iter::value_type;
  using iter_type = decltype(std::begin(*std::declval<join_iter>()));

  using value_type = typename std::iterator_traits<iter_type>::value_type;
  using reference = typename std::iterator_traits<iter_type>::reference;
  using pointer = typename std::iterator_traits<iter_type>::pointer;
  using difference_type =
      typename std::iterator_traits<iter_type>::difference_type;
  using iterator_category = std::forward_iterator_tag;

public:
  explicit joining_iterator() = default;

  template <typename I>
  joining_iterator(joining_iterator<I> const & other)
      : joiner_(other.join_iterator()), iterator_(other.element_iterator()) {}

  template <typename C, typename = std::enable_if_t<detail::is_container_v<C>>>
  joining_iterator(C && container)
      : joining_iterator(end_aware_iterator(std::forward<C>(container))) {}

  joining_iterator(end_aware_iterator<join_iter> join)
      : joining_iterator(join, {}, true) {}

  joining_iterator(end_aware_iterator<join_iter> join,
                   end_aware_iterator<iter_type> elem, bool update = false)
      : joiner_(join), iterator_(elem) {
    if (update) { update_iterator(); }
  }

  void increment() {
    if ((iterator_++).at_end()) {
      ++joiner_;
      update_iterator();
    }
  }

  decltype(auto) dereference() const { return *iterator_; }

  bool equal_to(joining_iterator const & other) const {
    return joiner_ == other.joiner_ && iterator_ == other.iterator_;
  }

  end_aware_iterator<join_iter> join_iterator() const { return joiner_; }
  end_aware_iterator<iter_type> element_iterator() const { return iterator_; }

private:
  void update_iterator() {
    while (!joiner_.at_end() && end_aware_iterator(*joiner_).at_end()) {
      ++joiner_;
    }
    if (!joiner_.at_end()) { iterator_ = end_aware_iterator(*joiner_); }
  }

  end_aware_iterator<join_iter> joiner_;
  end_aware_iterator<iter_type> iterator_;
};

template <typename C> joining_iterator(C &&) -> joining_iterator<iter<C>>;
template <typename JI>
joining_iterator(end_aware_iterator<JI>) -> joining_iterator<JI>;
template <typename JI, typename IT>
joining_iterator(end_aware_iterator<JI>, end_aware_iterator<IT>)
    -> joining_iterator<JI>;
}

MAKE_ITERATOR_FACADE_TYPEDEFS_T(::iterator::joining_iterator);