126 lines
3.3 KiB
C++
126 lines
3.3 KiB
C++
#pragma once
|
|
#include "types.hpp"
|
|
#include <cstddef>
|
|
#include <ranges>
|
|
#include <xutility>
|
|
|
|
namespace util {
|
|
namespace rg = std::ranges;
|
|
|
|
template <rg::range R> struct enumerate_iterator_t {
|
|
using base = rg::iterator_t<R>;
|
|
using enumerator_type = std::size_t;
|
|
using value_type = std::pair<enumerator_type, rg::range_value_t<R>>;
|
|
using difference_type = std::ptrdiff_t;
|
|
using reference =
|
|
std::pair<enumerator_type, std::remove_cv_t<rg::range_reference_t<R>>>;
|
|
|
|
base base_iter{};
|
|
enumerator_type enumerator{};
|
|
|
|
enumerate_iterator_t() = default;
|
|
enumerate_iterator_t(const base &b) : base_iter{b}, enumerator(0) {}
|
|
enumerate_iterator_t(base &&b) : base_iter{std::move(b)}, enumerator(0) {}
|
|
|
|
auto constexpr operator==(const enumerate_iterator_t &other) const -> bool {
|
|
return base_iter == other.base_iter;
|
|
}
|
|
|
|
template <std::sentinel_for<base> S>
|
|
auto constexpr operator==(const S &sentinel) const -> bool {
|
|
return sentinel == base_iter;
|
|
}
|
|
|
|
auto constexpr operator<=>(const enumerate_iterator_t &other) const {
|
|
return base_iter <=> other.base_iter;
|
|
}
|
|
|
|
auto inc_enumerator() -> void { enumerator++; }
|
|
auto dec_enumerator() -> void { enumerator--; }
|
|
auto dec_enumerator(const difference_type &n) -> void { enumerator -= n; }
|
|
|
|
auto operator++(int) -> enumerate_iterator_t {
|
|
const auto result = *this;
|
|
base_iter++;
|
|
inc_enumerator();
|
|
return result;
|
|
}
|
|
|
|
auto operator++() -> enumerate_iterator_t & {
|
|
inc_enumerator();
|
|
++base_iter;
|
|
return (*this);
|
|
}
|
|
|
|
auto operator--(int) -> enumerate_iterator_t
|
|
requires(std::bidirectional_iterator<base>) {
|
|
const auto result = *this;
|
|
base_iter--;
|
|
dec_enumerator();
|
|
return result;
|
|
}
|
|
|
|
auto operator--()
|
|
-> enumerate_iterator_t &requires(std::bidirectional_iterator<base>) {
|
|
dec_enumerator();
|
|
--base_iter;
|
|
return (*this);
|
|
}
|
|
|
|
auto constexpr operator+(const difference_type &n) const
|
|
-> enumerate_iterator_t {
|
|
auto ret = *this;
|
|
ret.inc_enumerator(n);
|
|
base_iter += n;
|
|
|
|
return ret;
|
|
}
|
|
|
|
auto operator*() -> reference { return reference(enumerator, *base_iter); }
|
|
auto operator*() const -> reference {
|
|
return reference(enumerator, *base_iter);
|
|
}
|
|
};
|
|
|
|
template <rg::range R>
|
|
class enumerate_view : public rg::view_interface<enumerate_view<R>> {
|
|
isize enumerator{};
|
|
enumerate_iterator_t<R> iter_;
|
|
enumerate_iterator_t<R> end_;
|
|
|
|
public:
|
|
enumerate_view() = default;
|
|
|
|
constexpr enumerate_view(R base)
|
|
: iter_(std::begin(base)), end_(std::end(base)) {}
|
|
|
|
constexpr auto begin() const { return iter_; }
|
|
constexpr auto end() const { return end_; }
|
|
};
|
|
|
|
namespace detail {
|
|
struct enumerate_range_adaptor_closure {
|
|
template <rg::viewable_range R> constexpr auto operator()(R &&r) const {
|
|
return enumerate_view(std::forward<R>(r));
|
|
}
|
|
};
|
|
|
|
struct enumerate_range_adaptor {
|
|
template <rg::viewable_range R> constexpr auto operator()(R &&r) {
|
|
return enumerate_view(std::forward<R>(r));
|
|
}
|
|
|
|
constexpr auto operator()() { return enumerate_range_adaptor_closure(); }
|
|
};
|
|
|
|
template <rg::viewable_range R>
|
|
constexpr auto operator|(R &&r, enumerate_range_adaptor_closure const &a) {
|
|
return a(std::forward<R>(r));
|
|
}
|
|
} // namespace detail
|
|
|
|
namespace views {
|
|
inline detail::enumerate_range_adaptor_closure enumerate;
|
|
} // namespace views
|
|
|
|
} // namespace util
|