Revision control
++ // Copyright (C) 2026 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #ifndef QITERATORFACADE_P_H
++ #define QITERATORFACADE_P_H
++
++ //
++ // W A R N I N G
++ // -------------
++ //
++ // This file is not part of the Qt API. It exists purely as an
++ // implementation detail. This header file may change from version to
++ // version without notice, or even be removed.
++ //
++ // We mean it.
++ //
++
++ #include <QtCore/qtconfigmacros.h>
++ #include <QtCore/qxptype_traits.h>
++
++ #include <iterator>
++ #include <type_traits>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QtMultimediaPrivate {
++
++ namespace impl {
++
++ #if defined(__cpp_concepts)
++
++ template <typename T>
++ concept has_increment = requires(T & t)
++ {
++ t.increment();
++ };
++
++ template <typename T>
++ concept has_decrement = requires(T & t)
++ {
++ t.decrement();
++ };
++
++ template <typename T>
++ concept has_equals = requires(const T &t1, const T &t2)
++ {
++ t1.equals(t2);
++ };
++
++ #else
++
++ template <typename T>
++ using increment_expr = decltype(std::declval<T &>().increment());
++
++ template <typename T>
++ using decrement_expr = decltype(std::declval<T &>().decrement());
++
++ template <typename T>
++ using equals_expr = decltype(std::declval<const T &>().equals(std::declval<const T &>()));
++
++ template <typename T>
++ constexpr bool has_increment = qxp::is_detected<increment_expr, T>::value;
++
++ template <typename T>
++ constexpr bool has_decrement = qxp::is_detected<decrement_expr, T>::value;
++
++ template <typename T>
++ constexpr bool has_equals = qxp::is_detected<equals_expr, T>::value;
++
++ #endif
++
++ } // namespace impl
++
++ // CRTP helper that turns a minimal iterator implementation into a full one.
++ //
++ // Derived must always implement:
++ // <value> dereference() const - access the current element
++ //
++ // and, for single-pass/forward/bidirectional iteration:
++ // void increment() - move one step forward
++ // bool equals(const Derived &o) const - compare iterator positions
++ // void decrement() - move one step backward (optional; enables operator--)
++ //
++ // For random access iteration, Derived may instead (or additionally) implement:
++ // void advance_by(difference_type n) - move n steps forward (n may be negative)
++ // difference_type distance_to(const Derived &o) const
++ // - signed number of steps from *this to o
++ template <typename Derived, typename ValueType, typename IteratorCategory = std::input_iterator_tag,
++ typename Reference = ValueType &, typename DifferenceType = std::ptrdiff_t>
++ class IteratorFacade
++ {
++ public:
++ using iterator_category = IteratorCategory;
++ using value_type = ValueType;
++ using reference = Reference;
++ using difference_type = DifferenceType;
++ using pointer = std::conditional_t<std::is_reference_v<Reference>,
++ std::remove_reference_t<Reference> *, void>;
++
++ constexpr decltype(auto) operator*() const { return derived().dereference(); }
++
++ constexpr Derived &operator++()
++ {
++ stepForward();
++ return derived();
++ }
++
++ constexpr Derived operator++(int)
++ {
++ Derived result = derived();
++ stepForward();
++ return result;
++ }
++
++ constexpr Derived &operator--()
++ {
++ stepBackward();
++ return derived();
++ }
++
++ constexpr Derived operator--(int)
++ {
++ Derived result = derived();
++ stepBackward();
++ return result;
++ }
++
++ template <typename N>
++ #if defined(__cpp_concepts)
++ requires requires(Derived &d, N n)
++ {
++ d.advance_by(n);
++ }
++ #endif
++ constexpr Derived &operator+=(N n)
++ {
++ derived().advance_by(n);
++ return derived();
++ }
++
++ template <typename N>
++ #if defined(__cpp_concepts)
++ requires requires(Derived &d, N n)
++ {
++ d.advance_by(n);
++ }
++ #endif
++ constexpr Derived &operator-=(N n)
++ {
++ derived().advance_by(-n);
++ return derived();
++ }
++
++ template <typename N>
++ #if defined(__cpp_concepts)
++ requires requires(Derived &d, N n)
++ {
++ d.advance_by(n);
++ }
++ #endif
++ friend constexpr Derived operator+(Derived it, N n)
++ {
++ it.advance_by(n);
++ return it;
++ }
++
++ template <typename N>
++ #if defined(__cpp_concepts)
++ requires requires(Derived &d, N n)
++ {
++ d.advance_by(n);
++ }
++ #endif
++ friend constexpr Derived operator+(N n, Derived it)
++ {
++ it.advance_by(n);
++ return it;
++ }
++
++ template <typename N>
++ #if defined(__cpp_concepts)
++ requires requires(Derived &d, N n)
++ {
++ d.advance_by(n);
++ }
++ #endif
++ friend constexpr Derived operator-(Derived it, N n)
++ {
++ it.advance_by(-n);
++ return it;
++ }
++
++ template <typename N>
++ #if defined(__cpp_concepts)
++ requires requires(Derived &d, N n)
++ {
++ d.advance_by(n);
++ }
++ #endif
++ friend constexpr Derived operator-(N n, Derived it)
++ {
++ it.advance_by(-n);
++ return it;
++ }
++
++ template <typename N>
++ #if defined(__cpp_concepts)
++ requires requires(Derived &d, N n)
++ {
++ d.advance_by(n);
++ }
++ #endif
++ constexpr decltype(auto) operator[](N n) const
++ {
++ Derived tmp = derived();
++ tmp.advance_by(n);
++ return tmp.dereference();
++ }
++
++ friend constexpr auto operator-(const Derived &lhs, const Derived &rhs)
++ #if defined(__cpp_concepts)
++ requires requires(const Derived &d)
++ {
++ d.distance_to(d);
++ }
++ #endif
++ {
++ return rhs.distance_to(lhs);
++ }
++
++ friend constexpr bool operator<(const Derived &lhs, const Derived &rhs)
++ #if defined(__cpp_concepts)
++ requires requires(const Derived &d)
++ {
++ d.distance_to(d);
++ }
++ #endif
++ {
++ return lhs.distance_to(rhs) > 0;
++ }
++
++ friend constexpr bool operator<=(const Derived &lhs, const Derived &rhs)
++ #if defined(__cpp_concepts)
++ requires requires(const Derived &d)
++ {
++ d.distance_to(d);
++ }
++ #endif
++ {
++ return lhs.distance_to(rhs) >= 0;
++ }
++
++ friend constexpr bool operator>(const Derived &lhs, const Derived &rhs)
++ #if defined(__cpp_concepts)
++ requires requires(const Derived &d)
++ {
++ d.distance_to(d);
++ }
++ #endif
++ {
++ return lhs.distance_to(rhs) < 0;
++ }
++
++ friend constexpr bool operator>=(const Derived &lhs, const Derived &rhs)
++ #if defined(__cpp_concepts)
++ requires requires(const Derived &d)
++ {
++ d.distance_to(d);
++ }
++ #endif
++ {
++ return lhs.distance_to(rhs) <= 0;
++ }
++
++ friend constexpr bool operator==(const Derived &lhs, const Derived &rhs)
++ {
++ return lhs.equalsImpl(rhs);
++ }
++
++ friend constexpr bool operator!=(const Derived &lhs, const Derived &rhs)
++ {
++ return !lhs.equalsImpl(rhs);
++ }
++
++ private:
++ constexpr Derived &derived() { return static_cast<Derived &>(*this); }
++ constexpr const Derived &derived() const { return static_cast<const Derived &>(*this); }
++
++ constexpr void stepForward() { stepForwardDispatch<impl::has_increment<Derived>>(); }
++
++ template <bool HasIncrement>
++ constexpr void stepForwardDispatch()
++ {
++ if constexpr (HasIncrement)
++ derived().increment();
++ else
++ derived().advance_by(1);
++ }
++
++ constexpr void stepBackward() { stepBackwardDispatch<impl::has_decrement<Derived>>(); }
++
++ template <bool HasDecrement>
++ constexpr void stepBackwardDispatch()
++ {
++ if constexpr (HasDecrement)
++ derived().decrement();
++ else
++ derived().advance_by(-1);
++ }
++
++ constexpr bool equalsImpl(const Derived &other) const
++ {
++ return equalsDispatch<impl::has_equals<Derived>>(other);
++ }
++
++ template <bool HasEquals>
++ constexpr bool equalsDispatch(const Derived &other) const
++ {
++ if constexpr (HasEquals)
++ return derived().equals(other);
++ else
++ return derived().distance_to(other) == 0;
++ }
++ };
++
++ } // namespace QtMultimediaPrivate
++
++ QT_END_NAMESPACE
++
++ #endif // QITERATORFACADE_P_H