cpp-useful-iterators/join_iterator.hpp

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

#pragma once

#include "iterator_fwd.hpp"
#include "end_aware_iterator.hpp"

#include <iterator>

namespace iterator {
template <typename MetaIterator>
class joining_iterator {
public:
  using join_iter = MetaIterator;
  using joinable_type = typename join_iter::value_type;
  using iter_type = detail::value_iterator<MetaIterator>;
 
  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( )
  : joiner_({}, {}), iterator_({}, {}) {
    
  }
  
  template <typename I>
  joining_iterator( joining_iterator<I> const & other )
  : joiner_(other.join_iterator()), iterator_(other.element_iterator()) {
    
  }
  
  joining_iterator( join_iter start, join_iter end )
  : joiner_(start, end), iterator_({}, {}) {
    update_iterator();
  }

  joining_iterator( join_iter start, join_iter end, iter_type lstart, iter_type lend, bool update = false )
  : joiner_(start, end), iterator_(lstart, lend) {
    if ( update ) { update_iterator(); }
  }

  joining_iterator & operator++() {
    if ( (++iterator_).done() ) {
      ++joiner_;
      update_iterator();
    }
    return *this;
  }
  
  joining_iterator operator++(int) {
    joining_iterator tmp{*this};
    operator++();
    return tmp;
  }
  
  reference operator*() { return iterator_.operator*(); }
  pointer operator->() { return iterator_.operator->(); }
  
  bool operator==(joining_iterator const & other) const {
    return joiner_ == other.joiner_ && ((joiner_.done() && other.joiner_.done()) ||
                                        iterator_ == other.iterator_);
  }
  
  bool operator!=(joining_iterator const & other) {
    return !(operator==(other));
  }
  
  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_.done() && std::begin(*joiner_) == std::end(*joiner_) ) {
      ++joiner_;
    }
    if ( !joiner_.done() ) {
      iterator_ = { std::begin(*joiner_), std::end(*joiner_) };
    }
  }
  
  end_aware_iterator<join_iter> joiner_;
  end_aware_iterator<iter_type> iterator_;
};
}