IndexedZipperIterator.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <tuple>
#include <optional>
#include <type_traits>
#include <iterator>
#include <iostream>
 
template <class... Containers>
class IndexedZipperIterator {
    template <class Container>
    using iterator_t = typename Container::iterator;
 
    template <class Container>
    using it_reference_t = decltype(std::declval<Container>()[0]);
 
public:
    using value = std::tuple<it_reference_t<Containers>...>;
    using value_type = std::tuple<std::size_t, it_reference_t<Containers>...>;
    using reference = value_type&; 
    using pointer = void; 
    using difference_type = std::size_t; 
    using iterator_category = std::forward_iterator_tag; 
    using iterator_tuple = std::tuple<iterator_t<Containers>...>;
 
    IndexedZipperIterator(iterator_tuple it_tuple, std::size_t max, std::size_t idx = 0) : _current(it_tuple), _max(max), _idx(idx) {}
 
    IndexedZipperIterator(const IndexedZipperIterator& z) : _current(z._current), _max(z._max), _idx(z._idx) {}
 
    IndexedZipperIterator& operator++() {
        incr_all(std::index_sequence_for<Containers...>());
        return *this;
    }
 
    IndexedZipperIterator operator++(int) {
        IndexedZipperIterator tmp(*this);
        ++(*this);
        return tmp;
    }
 
    value_type operator*() {
        return std::tuple_cat(std::make_tuple(_idx), to_value(std::index_sequence_for<Containers...>()));
    }
 
    value_type* operator->() {
        return &(*this);
    }
 
    friend bool operator==(const IndexedZipperIterator<Containers...> &lhs, const IndexedZipperIterator<Containers...> &rhs) {
        return lhs._idx == rhs._idx;
    }
 
    friend bool operator!=(const IndexedZipperIterator<Containers...> &lhs, const IndexedZipperIterator<Containers...> &rhs) {
        return lhs._idx != rhs._idx;
    }
 
private:
    template <std::size_t... Is>
    void incr_all(std::index_sequence<Is...>) {
        (++std::get<Is>(_current), ...);
        ++_idx;
 
        while (_idx < _max && !all_set(std::index_sequence<Is...>{})) {
            (++std::get<Is>(_current), ...);
            ++_idx;
        }
    }
 
    template <std::size_t... Is>
    bool all_set(std::index_sequence<Is...>) {
        return (... && std::get<Is>(_current)[0].has_value());
    }
 
    template <std::size_t... Is>
    value to_value(std::index_sequence<Is...>) {
        return std::tuple<it_reference_t<Containers>...>(*(std::get<Is>(_current))...);
    }
 
private:
    iterator_tuple _current; 
    std::size_t _max; 
    std::size_t _idx; 
    static constexpr std::index_sequence_for<Containers...> _seq{}; 
};