Views.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <ranges>
 
namespace SlHelpers::Views {

template<std::ranges::view V>
class PairwiseView : public std::ranges::view_interface<PairwiseView<V>> {
public:
    PairwiseView() : m_base(V()) {}
    explicit constexpr PairwiseView(V base) : m_base(std::move(base)) {}

    auto begin() { return Iterator{std::ranges::begin(m_base), std::ranges::end(m_base)}; }
    auto end() { return Sentinel{std::ranges::end(m_base)}; }

    struct Sentinel {
        std::ranges::iterator_t<V> m_end;
    };

    struct Iterator {
    private:
        std::ranges::iterator_t<V> m_cur;
        std::ranges::iterator_t<V> m_next;
        std::ranges::iterator_t<V> m_end;
    public:
        using ValueType = std::pair<decltype(*m_cur), decltype(*m_cur)>;

        Iterator(std::ranges::iterator_t<V> begin, std::ranges::iterator_t<V> end)
            : m_cur(begin), m_next(begin), m_end(end) {
            if (m_next != m_end)
                ++m_next;
        }

        ValueType operator*() const { return { *m_cur, *m_next }; }

        Iterator &operator++() {
            ++m_cur;
            ++m_next;
            return *this;
        }

        bool operator!=(Sentinel s) const { return m_cur != s.m_end && m_next != s.m_end; }
 
    };
private:
    V m_base;
};
 
template<class R>
PairwiseView(R&&) -> PairwiseView<std::views::all_t<R>>;

struct PairwiseFn {
    template<std::ranges::viewable_range R>
    auto operator()(R &&r) const {
        return PairwiseView(std::views::all(std::forward<R>(r)));
    }

    template<std::ranges::viewable_range R>
    friend auto operator|(R &&r, const PairwiseFn &fn) {
        return fn(std::forward<R>(r));
    }
};
 
inline constexpr PairwiseFn pairwise{};
 
} // namespace