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

//
//  unkeyed_iterator.hpp
//  iterator
//
//  Created by Sam Jaffe on 2/20/17.
//

#pragma once

#include <iterator>

namespace iterator {
  template <typename Iterator> class unkeyed_iterator {
  private:
    using impl_value_type = typename std::iterator_traits<Iterator>::value_type;
    using impl_reference = typename std::iterator_traits<Iterator>::reference;
    static constexpr std::size_t const value_index =
        std::tuple_size<impl_value_type>::value - 1;

  public:
    using value_type = typename std::remove_reference<decltype(
        std::get<value_index>(std::declval<impl_value_type>()))>::type;
    using reference =
        decltype(std::get<value_index>(std::declval<impl_reference>()));
    using pointer = value_type *;
    using difference_type =
        typename std::iterator_traits<Iterator>::difference_type;
    using iterator_category =
        typename std::iterator_traits<Iterator>::iterator_category;

    unkeyed_iterator() = default;
    unkeyed_iterator(Iterator it) : base(it) {}

    reference operator*() const { return std::get<value_index>(*base); }
    pointer operator->() const { return std::addressof(operator*()); }
    unkeyed_iterator & operator++() {
      ++base;
      return *this;
    }
    unkeyed_iterator operator++(int) {
      unkeyed_iterator tmp{*this};
      operator++();
      return tmp;
    }

    unkeyed_iterator & operator--() {
      --base;
      return *this;
    }
    unkeyed_iterator operator--(int) {
      unkeyed_iterator tmp{*this};
      operator--();
      return tmp;
    }

    unkeyed_iterator operator+(difference_type n) const {
      return unkeyed_iterator{*this} += n;
    }
    unkeyed_iterator & operator+=(difference_type n) {
      base += n;
      return *this;
    }
    unkeyed_iterator operator-(difference_type n) const {
      return unkeyed_iterator{*this} -= n;
    }
    unkeyed_iterator & operator-=(difference_type n) {
      base -= n;
      return *this;
    }

    bool operator==(unkeyed_iterator const & other) const {
      return base == other.base;
    }
    bool operator!=(unkeyed_iterator const & other) const {
      return base != other.base;
    }
    bool operator<(unkeyed_iterator const & other) const {
      return base < other.base;
    }
    bool operator<=(unkeyed_iterator const & other) const {
      return !(other < *this);
    }

  private:
    Iterator base;
  };
}