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

#pragma once

#include <iterator>
#include <tuple>

#include "detail/arrow_proxy.h"

namespace iterator {
  template <typename... Iterators> class zip_iterator {
  public:
    using value_type = std::tuple<typename Iterators::value_type...>;
    using reference = std::tuple<typename Iterators::reference...>;
    using pointer = void; // tuple cannot be accessed by member
    using difference_type =
        std::common_type_t<typename Iterators::difference_type...>;
    using iterator_category =
        std::common_type_t<typename Iterators::iterator_category...>;

  private:
    std::tuple<Iterators...> iterators_;

  public:
    zip_iterator() = default;
    zip_iterator(Iterators &&... iters) : iterators_(iters...) {}

    reference operator*() const {
      return reference(*std::get<Iterators>(iterators_)...);
    }

    zip_iterator & operator++() {
      [[maybe_unused]] auto l = {(++(std::get<Iterators>(iterators_)), 0)...};
      return *this;
    }

    zip_iterator operator++(int) {
      zip_iterator tmp = *this;
      operator++();
      return tmp;
    }

    zip_iterator & operator--() {
      [[maybe_unused]] auto l = {(--(std::get<Iterators>(iterators_)), 0)...};
      return *this;
    }

    zip_iterator operator--(int) {
      zip_iterator tmp = *this;
      operator--();
      return tmp;
    }

    zip_iterator & operator+=(difference_type d) {
      [[maybe_unused]] auto l = {
          ((std::get<Iterators>(iterators_) += d), 0)...};
      return *this;
    }

    zip_iterator operator+(difference_type d) {
      return zip_iterator{*this} += d;
    }

    reference operator[](difference_type d) { return *(*this + d); }

    zip_iterator & operator-=(difference_type d) {
      [[maybe_unused]] auto l = {
          ((std::get<Iterators>(iterators_) -= d), 0)...};
      return *this;
    }

    zip_iterator operator-(difference_type d) {
      return zip_iterator{*this} -= d;
    }

    difference_type operator-(zip_iterator const & other) {
      return std::get<0>(iterators_) - std::get<0>(other.iterators_);
    }

    bool operator==(zip_iterator const & rhs) const {
      return iterators_ == rhs.iterators_;
    }
    bool operator!=(zip_iterator const & rhs) const {
      return iterators_ != rhs.iterators_;
    }
    bool operator<(zip_iterator const & rhs) const {
      return iterators_ < rhs.iterators_;
    }
    bool operator<=(zip_iterator const & rhs) const {
      return iterators_ <= rhs.iterators_;
    }
    bool operator>(zip_iterator const & rhs) const {
      return iterators_ > rhs.iterators_;
    }
    bool operator>=(zip_iterator const & rhs) const {
      return iterators_ <= rhs.iterators_;
    }
  };

  template <typename... Is>
  zip_iterator<Is...> operator+(typename zip_iterator<Is...>::difference_type d,
                                zip_iterator<Is...> iter) {
    return iter += d;
  }
}

template <typename... Is>
iterator::zip_iterator<Is...> make_zip_iterator(Is &&... iters) {
  return {std::forward<Is>(iters)...};
}