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

#pragma once

#include <iterator>
#include <tuple>

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

namespace iterator::detail {
template <typename Tuple, typename IS> class zip_iterator_impl;

template <typename... Ts, size_t... Is>
class zip_iterator_impl<std::tuple<Ts...>, std::index_sequence<Is...>> {
public:
  using difference_type =
      std::common_type_t<typename std::iterator_traits<Ts>::difference_type...>;

public:
  zip_iterator_impl() = default;
  zip_iterator_impl(Ts... iters) : _data(iters...) {}

  auto dereference() const {
    return std::forward_as_tuple(*std::get<Is>(_data)...);
  }

  void increment() {
    [[maybe_unused]] auto l = {((++std::get<Is>(_data)), 0)...};
  }
  void decrement()
    requires(std::bidirectional_iterator<Ts> && ...)
  {
    [[maybe_unused]] auto l = {((--std::get<Is>(_data)), 0)...};
  }
  void advance(difference_type d)
    requires(std::random_access_iterator<Ts> && ...)
  {
    [[maybe_unused]] auto l = {((std::get<Is>(_data) += d), 0)...};
  }

  bool equal_to(zip_iterator_impl const & other) const {
    return _data == other._data;
  }

  auto distance_to(zip_iterator_impl const & other) const
    requires(std::random_access_iterator<Ts> && ...)
  {
    return std::get<0>(other._data) - std::get<0>(_data);
  }

private:
  std::tuple<Ts...> _data;
};
}

namespace iterator {
template <typename... Ts>
using index_sequence = decltype(std::make_index_sequence<sizeof...(Ts)>{});
template <typename... Ts>
using zip_impl =
    detail::zip_iterator_impl<std::tuple<Ts...>, index_sequence<Ts...>>;

template <typename... Iters>
class zip_iterator : public zip_impl<Iters...>,
                     public facade<zip_iterator<Iters...>> {
public:
  zip_iterator() = default;
  zip_iterator(Iters... iters) : zip_impl<Iters...>(iters...) {}
};

template <typename... It> zip_iterator(It...) -> zip_iterator<It...>;
}