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

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

#pragma once

#include <iterator>
#include <memory>
#include <utility>

#include <iterator/capture_iterator.h>
#include <iterator/end_aware_iterator.h>
#include <iterator/facade.h>
#include <iterator/forwards.h>

#include <iterator/detail/macro.h>

namespace iterator {
template <typename It>
class joining_iterator
    : public facade<joining_iterator<It>> {
private:
  template <typename Ot> friend class joining_iterator;
  constexpr static bool requires_caching = !std::is_reference_v<DEREF_TYPE(It)>;

public:
  using sentinel_type = sentinel_t;
  using outer_iterator_t =
      std::conditional_t<requires_caching,
                         capture_iterator<end_aware_iterator<It>>,
                         end_aware_iterator<It>>;
  using inner_iterator_t =
      end_aware_iterator<iterator_t<DEREF_TYPE(outer_iterator_t)>>;

private:
  outer_iterator_t outer_;
  inner_iterator_t inner_;

public:
  joining_iterator() = default;

  template <typename Ot>
  joining_iterator(joining_iterator<Ot> const & other) : outer_(other.outer_) {
    safely_init_inner_iterator(other.outer_, other.inner_);
  }

  joining_iterator(Range auto & container) : outer_(FWD(container)) {
    update_iterator();
  }

  joining_iterator(outer_iterator_t outer) : outer_(outer) {
    update_iterator();
  }

  joining_iterator(outer_iterator_t const & outer,
                   inner_iterator_t const & inner)
      : outer_(outer) {
    safely_init_inner_iterator(outer, inner);
  }

  void increment() {
    if ((++inner_).at_end()) {
      ++outer_;
      update_iterator();
    }
  }

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

  bool at_end() const { return outer_.at_end(); }
  bool equal_to(joining_iterator const & other) const {
    return outer_ == other.outer_ && inner_ == other.inner_;
  }

  auto outer_iterator() const { return outer_; }
  auto inner_iterator() const { return inner_; }

private:
  template <typename OuterIt, typename InnerIt>
  void safely_init_inner_iterator(OuterIt const & outer,
                                  InnerIt const & inner) {
    if constexpr (requires_caching) {
      inner_ = *outer_;
      std::advance(inner_, std::distance(InnerIt(*outer), inner));
    } else {
      inner_ = inner;
    }
  }

  void update_iterator() {
    while (!outer_.at_end() && (inner_ = *outer_).at_end()) {
      ++outer_;
    }
  }
};

template <typename C>
joining_iterator(C &) -> joining_iterator<iterator_t<C>>;
template <typename JI>
joining_iterator(end_aware_iterator<JI>) -> joining_iterator<JI>;
}

#include <iterator/detail/undef.h>