path: root/src/corelib/global/qcomparehelpers.h

// Copyright (C) 2023 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 QCOMPARE_H#error"Do not include qcomparehelpers.h directly. Use qcompare.h instead."#endif#ifndef QCOMPAREHELPERS_H#define QCOMPAREHELPERS_H#if 0#pragma qt_no_master_include#pragma qt_sync_skip_header_check#pragma qt_sync_stop_processing#endif#include <QtCore/qflags.h>#include <QtCore/qoverload.h>#include <QtCore/qttypetraits.h>#include <QtCore/qtypeinfo.h>#include <QtCore/qtypes.h>#ifdef __cpp_lib_three_way_comparison#include <compare>#endif#include <QtCore/q20type_traits.h>#include <functional>// std::less, std::hash QT_BEGIN_NAMESPACE class QPartialOrdering;namespace QtOrderingPrivate {template<typename T>struct is_std_ordering_type :std::false_type {};template<typename T>struct is_qt_ordering_type :std::false_type {};template<typename T>constexprbool is_std_ordering_type_v = is_std_ordering_type<T>::value;template<typename T>constexprbool is_qt_ordering_type_v = is_qt_ordering_type<T>::value;enumclass QtOrderingType { QtOrder =0x00, StdOrder =0x01, Partial =0x00, Weak =0x20, Strong =0x40, StrengthMask = Weak|Strong,};Q_DECLARE_FLAGS(QtOrderingTypeFlag, QtOrderingType)Q_DECLARE_OPERATORS_FOR_FLAGS(QtOrderingPrivate::QtOrderingTypeFlag)template<typename QtOrdering>struct StdOrdering;template<typename StdOrdering>struct QtOrdering;#ifdef __cpp_lib_three_way_comparison#define QT_STD_MAP(x) \ template <> struct StdOrdering< Qt::x##_ordering> : q20::type_identity<std::x##_ordering> {};\ template <> struct StdOrdering<std::x##_ordering> : q20::type_identity<std::x##_ordering> {};\ template <> struct QtOrdering<std::x##_ordering> : q20::type_identity< Qt::x##_ordering> {};\ template <> struct QtOrdering< Qt::x##_ordering> : q20::type_identity< Qt::x##_ordering> {};\ template <> struct is_std_ordering_type<std::x##_ordering> : std::true_type {};\ template <> struct is_qt_ordering_type< Qt::x##_ordering> : std::true_type {};\/* end */QT_STD_MAP(partial)QT_STD_MAP(weak)QT_STD_MAP(strong)#undef QT_STD_MAPtemplate<>struct StdOrdering<QPartialOrdering> :q20::type_identity<std::partial_ordering> {};template<>struct QtOrdering<QPartialOrdering> :q20::type_identity<Qt::partial_ordering> {};#elsetemplate<>struct is_qt_ordering_type<Qt::partial_ordering> :std::true_type {};template<>struct is_qt_ordering_type<Qt::weak_ordering> :std::true_type {};template<>struct is_qt_ordering_type<Qt::strong_ordering> :std::true_type {};#endif// __cpp_lib_three_way_comparisontemplate<typename In>constexpr autoto_std(In in) noexcept -> typename QtOrderingPrivate::StdOrdering<In>::type {return in; }template<typename In>constexpr autoto_Qt(In in) noexcept -> typename QtOrderingPrivate::QtOrdering<In>::type {return in; }template<typename T>constexprbool is_ordering_type_v =std::disjunction_v<is_qt_ordering_type<T>, is_std_ordering_type<T>>;template<typename T>constexpr std::enable_if_t<is_qt_ordering_type_v<T>, QtOrderingTypeFlag>orderingFlagsFor(T t) noexcept { QtOrderingTypeFlag flags =QtOrderingType::QtOrder;Qt::partial_ordering convertedOrder(t);ifconstexpr(std::is_same_v<T,Qt::strong_ordering>) flags = flags |QtOrderingType::Strong;else ifconstexpr(std::is_same_v<T,Qt::partial_ordering>) flags = flags |QtOrderingType::Partial;else ifconstexpr(std::is_same_v<T,Qt::weak_ordering>) flags = flags |QtOrderingType::Weak;return flags;}template<typename T>constexpr std::enable_if_t<is_std_ordering_type_v<T>, QtOrderingTypeFlag>orderingFlagsFor(T t) noexcept {QtOrderingPrivate::QtOrderingTypeFlag flags =QtOrderingPrivate::QtOrderingType::StdOrder;returnQtOrderingTypeFlag(flags |QtOrderingPrivate::orderingFlagsFor(QtOrderingPrivate::to_Qt(t)));}}// namespace QtOrderingPrivate/* For all the macros these parameter names are used: * LeftType - the type of the left operand of the comparison * RightType - the type of the right operand of the comparison * Constexpr - must be either constexpr or empty. Defines whether the operator is constexpr or not * Noexcept - a noexcept specifier. By default the relational operators are expected to be noexcept. However, there are some cases when this cannot be achieved (e.g. QDir). The public macros will pass noexcept(true) or noexcept(false) in this parameter, because conditional noexcept is known to cause some issues. However, internally we might want to pass a predicate here for some specific classes (e.g. QList, etc). * Attributes... - an optional list of attributes. For example, pass \c QT_ASCII_CAST_WARN when defining comparisons between C-style string and an encoding-aware string type. This is a variable argument, and can now include up to 7 comma-separated parameters. The macros require two helper functions. For operators to be constexpr, these must be constexpr, too. Additionally, other attributes (like Q_<Module>_EXPORT, Q_DECL_CONST_FUNCTION, etc) can be applied to them. Aside from that, their declaration should match: bool comparesEqual(LeftType, RightType) noexcept; ReturnType compareThreeWay(LeftType, RightType) noexcept; The ReturnType can be one of Qt::{partial,weak,strong}_ordering. The actual type depends on the macro being used. It makes sense to define the helper functions as hidden friends of the class, so that they could be found via ADL, and don't participate in unintended implicit conversions.*//* Some systems (e.g. QNX and Integrity (GHS compiler)) have bugs in handling conditional noexcept in lambdas. This macro is needed to overcome such bugs and provide a noexcept check only on platforms that behave normally. It does nothing on the systems that have problems. This hack is explicitly disabled for C++20 because we want the compilers to fix the known issues before switching.*/#if defined(__cpp_lib_three_way_comparison) || !(defined(Q_OS_QNX) || defined(Q_CC_GHS))# define QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, Func) \ constexpr auto f = []() Noexcept {}; \ static_assert(!noexcept(f()) || noexcept(Func(lhs, rhs)), \"Use *_NON_NOEXCEPT version of the macro, " \"or make the helper function noexcept")#else# define QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, Func)/* no check */#endif// Seems that qdoc uses C++20 even when Qt is compiled in C++17 mode.// Or at least it defines __cpp_lib_three_way_comparison.// Let qdoc see only the C++17 operators for now, because that's what our docs// currently describe.#if defined(__cpp_lib_three_way_comparison) && !defined(Q_QDOC)// C++20 - provide operator==() for equality, and operator<=>() for ordering#define QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr bool operator==(LeftType const &lhs, RightType const &rhs) Noexcept \ { \ QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, comparesEqual); \ return comparesEqual(lhs, rhs); \ }#define QT_DECLARE_ORDERING_HELPER_STRONG(LeftType, RightType, Constexpr, Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr std::strong_ordering \ operator<=>(LeftType const &lhs, RightType const &rhs) Noexcept \ { \ QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, compareThreeWay); \ return compareThreeWay(lhs, rhs); \ }#define QT_DECLARE_ORDERING_HELPER_WEAK(LeftType, RightType, Constexpr, Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr std::weak_ordering \ operator<=>(LeftType const &lhs, RightType const &rhs) Noexcept \ { \ QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, compareThreeWay); \ return compareThreeWay(lhs, rhs); \ }#define QT_DECLARE_ORDERING_HELPER_PARTIAL(LeftType, RightType, Constexpr, Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr std::partial_ordering \ operator<=>(LeftType const &lhs, RightType const &rhs) Noexcept \ { \ QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, compareThreeWay); \ return compareThreeWay(lhs, rhs); \ }#define QT_DECLARE_ORDERING_HELPER_AUTO(LeftType, RightType, Constexpr, Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr auto \ operator<=>(LeftType const &lhs, RightType const &rhs) Noexcept \ { \ QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, compareThreeWay);\ return QtOrderingPrivate::to_std(compareThreeWay(lhs, rhs)); \ }#define QT_DECLARE_ORDERING_OPERATORS_HELPER(OrderingType, LeftType, RightType, Constexpr, \ Noexcept, ...) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType, Constexpr, Noexcept, __VA_ARGS__) \ QT_DECLARE_ORDERING_HELPER_ ## OrderingType (LeftType, RightType, Constexpr, Noexcept, \ __VA_ARGS__)#ifdef Q_COMPILER_LACKS_THREE_WAY_COMPARE_SYMMETRY// define reversed versions of the operators manually, because buggy MSVC versions do not do it#define QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr bool operator==(RightType const &lhs, LeftType const &rhs) Noexcept \ { return comparesEqual(rhs, lhs); }#define QT_DECLARE_REVERSED_ORDERING_HELPER_STRONG(LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr std::strong_ordering \ operator<=>(RightType const &lhs, LeftType const &rhs) Noexcept \ { \ const auto r = compareThreeWay(rhs, lhs); \ return QtOrderingPrivate::reversed(r); \ }#define QT_DECLARE_REVERSED_ORDERING_HELPER_WEAK(LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr std::weak_ordering \ operator<=>(RightType const &lhs, LeftType const &rhs) Noexcept \ { \ const auto r = compareThreeWay(rhs, lhs); \ return QtOrderingPrivate::reversed(r); \ }#define QT_DECLARE_REVERSED_ORDERING_HELPER_PARTIAL(LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr std::partial_ordering \ operator<=>(RightType const &lhs, LeftType const &rhs) Noexcept \ { \ const auto r = compareThreeWay(rhs, lhs); \ return QtOrderingPrivate::reversed(r); \ }#define QT_DECLARE_REVERSED_ORDERING_HELPER_AUTO(LeftType, RightType, Constexpr, Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr auto \ operator<=>(RightType const &lhs, LeftType const &rhs) Noexcept \ { \ const auto r = compareThreeWay(rhs, lhs); \ return QtOrderingPrivate::to_std(QtOrderingPrivate::reversed(r)); \ }#define QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(OrderingString, LeftType, RightType, \ Constexpr, Noexcept, ...) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType, Constexpr, \ Noexcept, __VA_ARGS__) \ QT_DECLARE_REVERSED_ORDERING_HELPER_ ## OrderingString (LeftType, RightType, Constexpr, \ Noexcept, __VA_ARGS__)#else// dummy macros for C++17 compatibility, reversed operators are generated by the compiler#define QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType, Constexpr, \ Noexcept, ...)#define QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(OrderingString, LeftType, RightType, \ Constexpr, Noexcept, ...)#endif// Q_COMPILER_LACKS_THREE_WAY_COMPARE_SYMMETRY#else// C++17 - provide operator==() and operator!=() for equality,// and all 4 comparison operators for ordering#define QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr bool operator==(LeftType const &lhs, RightType const &rhs) Noexcept \ { \ QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, comparesEqual); \ return comparesEqual(lhs, rhs); \ } \ __VA_ARGS__ \ friend Constexpr bool operator!=(LeftType const &lhs, RightType const &rhs) Noexcept \ { return !comparesEqual(lhs, rhs); }// Helpers for reversed comparison, using the existing comparesEqual() function.#define QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr bool operator==(RightType const &lhs, LeftType const &rhs) Noexcept \ { return comparesEqual(rhs, lhs); } \ __VA_ARGS__ \ friend Constexpr bool operator!=(RightType const &lhs, LeftType const &rhs) Noexcept \ { return !comparesEqual(rhs, lhs); }#define QT_DECLARE_ORDERING_HELPER_TEMPLATE(OrderingType, LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr bool operator<(LeftType const &lhs, RightType const &rhs) Noexcept \ { \ QT_COMPARISON_NOEXCEPT_CHECK(Noexcept, compareThreeWay); \ return is_lt(compareThreeWay(lhs, rhs)); \ } \ __VA_ARGS__ \ friend Constexpr bool operator>(LeftType const &lhs, RightType const &rhs) Noexcept \ { return is_gt(compareThreeWay(lhs, rhs)); } \ __VA_ARGS__ \ friend Constexpr bool operator<=(LeftType const &lhs, RightType const &rhs) Noexcept \ { return is_lteq(compareThreeWay(lhs, rhs)); } \ __VA_ARGS__ \ friend Constexpr bool operator>=(LeftType const &lhs, RightType const &rhs) Noexcept \ { return is_gteq(compareThreeWay(lhs, rhs)); }#define QT_DECLARE_ORDERING_HELPER_AUTO(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_ORDERING_HELPER_TEMPLATE(auto, LeftType, RightType, Constexpr, Noexcept, \ __VA_ARGS__)#define QT_DECLARE_ORDERING_HELPER_PARTIAL(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_ORDERING_HELPER_TEMPLATE(Qt::partial_ordering, LeftType, RightType, Constexpr, \ Noexcept, __VA_ARGS__)#define QT_DECLARE_ORDERING_HELPER_WEAK(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_ORDERING_HELPER_TEMPLATE(Qt::weak_ordering, LeftType, RightType, Constexpr, \ Noexcept, __VA_ARGS__)#define QT_DECLARE_ORDERING_HELPER_STRONG(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_ORDERING_HELPER_TEMPLATE(Qt::strong_ordering, LeftType, RightType, Constexpr, \ Noexcept, __VA_ARGS__)#define QT_DECLARE_ORDERING_OPERATORS_HELPER(OrderingString, LeftType, RightType, Constexpr, \ Noexcept, ...) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType, Constexpr, Noexcept, __VA_ARGS__) \ QT_DECLARE_ORDERING_HELPER_ ## OrderingString (LeftType, RightType, Constexpr, Noexcept, \ __VA_ARGS__)// Helpers for reversed ordering, using the existing compareThreeWay() function.#define QT_DECLARE_REVERSED_ORDERING_HELPER_TEMPLATE(OrderingType, LeftType, RightType, Constexpr, \ Noexcept, ...) \ __VA_ARGS__ \ friend Constexpr bool operator<(RightType const &lhs, LeftType const &rhs) Noexcept \ { return is_gt(compareThreeWay(rhs, lhs)); } \ __VA_ARGS__ \ friend Constexpr bool operator>(RightType const &lhs, LeftType const &rhs) Noexcept \ { return is_lt(compareThreeWay(rhs, lhs)); } \ __VA_ARGS__ \ friend Constexpr bool operator<=(RightType const &lhs, LeftType const &rhs) Noexcept \ { return is_gteq(compareThreeWay(rhs, lhs)); } \ __VA_ARGS__ \ friend Constexpr bool operator>=(RightType const &lhs, LeftType const &rhs) Noexcept \ { return is_lteq(compareThreeWay(rhs, lhs)); }#define QT_DECLARE_REVERSED_ORDERING_HELPER_AUTO(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_REVERSED_ORDERING_HELPER_TEMPLATE(auto, LeftType, RightType, Constexpr, Noexcept, \ __VA_ARGS__)#define QT_DECLARE_REVERSED_ORDERING_HELPER_PARTIAL(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_REVERSED_ORDERING_HELPER_TEMPLATE(Qt::partial_ordering, LeftType, RightType, \ Constexpr, Noexcept, __VA_ARGS__)#define QT_DECLARE_REVERSED_ORDERING_HELPER_WEAK(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_REVERSED_ORDERING_HELPER_TEMPLATE(Qt::weak_ordering, LeftType, RightType, \ Constexpr, Noexcept, __VA_ARGS__)#define QT_DECLARE_REVERSED_ORDERING_HELPER_STRONG(LeftType, RightType, Constexpr, Noexcept, ...) \ QT_DECLARE_REVERSED_ORDERING_HELPER_TEMPLATE(Qt::strong_ordering, LeftType, RightType, \ Constexpr, Noexcept, __VA_ARGS__)#define QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(OrderingString, LeftType, RightType, \ Constexpr, Noexcept, ...) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType, Constexpr, Noexcept, \ __VA_ARGS__) \ QT_DECLARE_REVERSED_ORDERING_HELPER_ ## OrderingString (LeftType, RightType, Constexpr, \ Noexcept, __VA_ARGS__)#endif// __cpp_lib_three_way_comparison/* Public API starts here */// Equality operators#define QT_DECLARE_EQUALITY_COMPARABLE_1(Type) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(Type, Type,/* non-constexpr */, noexcept(true), \/* no attributes */)#define QT_DECLARE_EQUALITY_COMPARABLE_2(LeftType, RightType) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */)#define QT_DECLARE_EQUALITY_COMPARABLE_3(LeftType, RightType, ...) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__)#define QT_DECLARE_EQUALITY_COMPARABLE_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_3(__VA_ARGS__))#define Q_DECLARE_EQUALITY_COMPARABLE(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_EQUALITY_COMPARABLE, __VA_ARGS__)#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_1(Type) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(Type, Type, constexpr, noexcept(true), \/* no attributes */)#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_2(LeftType, RightType) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType, constexpr, noexcept(true), \/* no attributes */) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */)#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_3(LeftType, RightType, ...) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType, constexpr, noexcept(true), \ __VA_ARGS__) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType, constexpr, noexcept(true), \ __VA_ARGS__)#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE_3(__VA_ARGS__))#define Q_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_EQUALITY_COMPARABLE_LITERAL_TYPE, __VA_ARGS__)#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_1(Type) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(Type, Type,/* non-constexpr */, noexcept(false), \/* no attributes */)#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_2(LeftType, RightType) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */)#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_3(LeftType, RightType, ...) \ QT_DECLARE_EQUALITY_OPERATORS_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__) \ QT_DECLARE_EQUALITY_OPERATORS_REVERSED_HELPER(LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__)#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT_3(__VA_ARGS__))#define Q_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_EQUALITY_COMPARABLE_NON_NOEXCEPT, __VA_ARGS__)// Ordering operators that automatically deduce the strength:#define QT_DECLARE_ORDERED_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, Type, Type,/* non-constexpr */, noexcept(true), \/* no attributes */)#define QT_DECLARE_ORDERED_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */)#define QT_DECLARE_ORDERED_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__)#define QT_DECLARE_ORDERED_4(...) QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_5(...) QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_6(...) QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_7(...) QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_8(...) QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_9(...) QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_3(__VA_ARGS__))#define Q_DECLARE_ORDERED(...) QT_OVERLOADED_MACRO(QT_DECLARE_ORDERED, __VA_ARGS__)#define QT_DECLARE_ORDERED_LITERAL_TYPE_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, Type, Type, constexpr, noexcept(true), \/* no attributes */)#define QT_DECLARE_ORDERED_LITERAL_TYPE_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(AUTO, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */)#define QT_DECLARE_ORDERED_LITERAL_TYPE_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, LeftType, RightType, constexpr, \ noexcept(true), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(AUTO, LeftType, RightType, constexpr, \ noexcept(true), __VA_ARGS__)#define QT_DECLARE_ORDERED_LITERAL_TYPE_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_LITERAL_TYPE_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_LITERAL_TYPE_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_LITERAL_TYPE_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_LITERAL_TYPE_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_LITERAL_TYPE_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define Q_DECLARE_ORDERED_LITERAL_TYPE(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_ORDERED_LITERAL_TYPE, __VA_ARGS__)#define QT_DECLARE_ORDERED_NON_NOEXCEPT_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, Type, Type,/* non-constexpr */, noexcept(false), \/* no attributes */)#define QT_DECLARE_ORDERED_NON_NOEXCEPT_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */)#define QT_DECLARE_ORDERED_NON_NOEXCEPT_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(AUTO, LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__)#define QT_DECLARE_ORDERED_NON_NOEXCEPT_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_NON_NOEXCEPT_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_NON_NOEXCEPT_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_NON_NOEXCEPT_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_NON_NOEXCEPT_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_ORDERED_NON_NOEXCEPT_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define Q_DECLARE_ORDERED_NON_NOEXCEPT(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_ORDERED_NON_NOEXCEPT, __VA_ARGS__)// Partial ordering operators#define QT_DECLARE_PARTIALLY_ORDERED_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, Type, Type,/* non-constexpr */, \ noexcept(true),/* no attributes */)#define QT_DECLARE_PARTIALLY_ORDERED_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(PARTIAL, LeftType, RightType, \/* non-constexpr */, noexcept(true), \/* no attributes */)#define QT_DECLARE_PARTIALLY_ORDERED_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(PARTIAL, LeftType, RightType, \/* non-constexpr */, noexcept(true), __VA_ARGS__)#define QT_DECLARE_PARTIALLY_ORDERED_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_3(__VA_ARGS__))#define Q_DECLARE_PARTIALLY_ORDERED(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_PARTIALLY_ORDERED, __VA_ARGS__)#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, Type, Type, constexpr, noexcept(true), \/* no attributes */)#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(PARTIAL, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */)#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, LeftType, RightType, constexpr, noexcept(true), \ __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(PARTIAL, LeftType, RightType, constexpr, \ noexcept(true), __VA_ARGS__)#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define Q_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_PARTIALLY_ORDERED_LITERAL_TYPE, __VA_ARGS__)#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, Type, Type,/* non-constexpr */, \ noexcept(false),/* no attributes */)#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(PARTIAL, LeftType, RightType, \/* non-constexpr */, noexcept(false), \/* no attributes */)#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(PARTIAL, LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(PARTIAL, LeftType, RightType, \/* non-constexpr */, noexcept(false), __VA_ARGS__)#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define Q_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_PARTIALLY_ORDERED_NON_NOEXCEPT, __VA_ARGS__)// Weak ordering operators#define QT_DECLARE_WEAKLY_ORDERED_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, Type, Type,/* non-constexpr */, noexcept(true), \/* no attributes */)#define QT_DECLARE_WEAKLY_ORDERED_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */)#define QT_DECLARE_WEAKLY_ORDERED_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__)#define QT_DECLARE_WEAKLY_ORDERED_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_3(__VA_ARGS__))#define Q_DECLARE_WEAKLY_ORDERED(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_WEAKLY_ORDERED, __VA_ARGS__)#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, Type, Type, constexpr, noexcept(true), \/* no attributes */)#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(WEAK, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */)#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, LeftType, RightType, constexpr, noexcept(true), \ __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(WEAK, LeftType, RightType, constexpr, \ noexcept(true), __VA_ARGS__)#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define Q_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_WEAKLY_ORDERED_LITERAL_TYPE, __VA_ARGS__)#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, Type, Type,/* non-constexpr */, noexcept(false), \/* no attributes */)#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */)#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(WEAK, LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__)#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define Q_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_WEAKLY_ORDERED_NON_NOEXCEPT, __VA_ARGS__)// Strong ordering operators#define QT_DECLARE_STRONGLY_ORDERED_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, Type, Type,/* non-constexpr */, \ noexcept(true),/* no attributes */)#define QT_DECLARE_STRONGLY_ORDERED_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, LeftType, RightType,/* non-constexpr */, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(STRONG, LeftType, RightType, \/* non-constexpr */, noexcept(true), \/* no attributes */)#define QT_DECLARE_STRONGLY_ORDERED_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, LeftType, RightType,/* non-constexpr */, \ noexcept(true), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(STRONG, LeftType, RightType, \/* non-constexpr */, noexcept(true), __VA_ARGS__)#define QT_DECLARE_STRONGLY_ORDERED_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_3(__VA_ARGS__))#define Q_DECLARE_STRONGLY_ORDERED(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_STRONGLY_ORDERED, __VA_ARGS__)#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, Type, Type, constexpr, noexcept(true), \/* no attributes */)#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(STRONG, LeftType, RightType, constexpr, \ noexcept(true),/* no attributes */)#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, LeftType, RightType, constexpr, noexcept(true), \ __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(STRONG, LeftType, RightType, constexpr, \ noexcept(true), __VA_ARGS__)#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE_3(__VA_ARGS__))#define Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE, __VA_ARGS__)#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_1(Type) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, Type, Type,/* non-constexpr */, \ noexcept(false),/* no attributes */)#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_2(LeftType, RightType) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, LeftType, RightType,/* non-constexpr */, \ noexcept(false),/* no attributes */) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(STRONG, LeftType, RightType, \/* non-constexpr */, noexcept(false), \/* no attributes */)#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_3(LeftType, RightType, ...) \ QT_DECLARE_ORDERING_OPERATORS_HELPER(STRONG, LeftType, RightType,/* non-constexpr */, \ noexcept(false), __VA_ARGS__) \ QT_DECLARE_ORDERING_OPERATORS_REVERSED_HELPER(STRONG, LeftType, RightType, \/* non-constexpr */, noexcept(false), __VA_ARGS__)#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_4(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_5(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_6(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_7(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_8(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_9(...) \ QT_VA_ARGS_EXPAND(QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT_3(__VA_ARGS__))#define Q_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT(...) \ QT_OVERLOADED_MACRO(QT_DECLARE_STRONGLY_ORDERED_NON_NOEXCEPT, __VA_ARGS__)namespace QtPrivate {template<typename T>constexprbool IsIntegralType_v =std::numeric_limits<std::remove_const_t<T>>::is_specialized &&std::numeric_limits<std::remove_const_t<T>>::is_integer;template<typename T>constexprbool IsFloatType_v =std::is_floating_point_v<T>;#if QFLOAT16_IS_NATIVEtemplate<>inline constexprbool IsFloatType_v<QtPrivate::NativeFloat16Type> =true;#endif}// namespace QtPrivatenamespace QtOrderingPrivate {template<typename T, typename U>constexpr Qt::strong_ordering strongOrderingCompareDefaultImpl(T lhs, U rhs) noexcept {#ifdef __cpp_lib_three_way_comparisonreturn lhs <=> rhs;#elseif(lhs == rhs)returnQt::strong_ordering::equivalent;else if(lhs < rhs)returnQt::strong_ordering::less;elsereturnQt::strong_ordering::greater;#endif// __cpp_lib_three_way_comparison}}// namespace QtOrderingPrivatenamespace Qt {template<typename T>using if_integral =std::enable_if_t<QtPrivate::IsIntegralType_v<T>,bool>;template<typename T>using if_floating_point =std::enable_if_t<QtPrivate::IsFloatType_v<T>,bool>;template<typename T, typename U>using if_compatible_pointers =std::enable_if_t<std::disjunction_v<std::is_same<T, U>,std::is_base_of<T, U>,std::is_base_of<U, T>>,bool>;template<typename Enum>using if_enum =std::enable_if_t<std::is_enum_v<Enum>,bool>;template<typename LeftInt, typename RightInt, if_integral<LeftInt> =true, if_integral<RightInt> =true>constexpr Qt::strong_ordering compareThreeWay(LeftInt lhs, RightInt rhs) noexcept {static_assert(std::is_signed_v<LeftInt> ==std::is_signed_v<RightInt>,"Qt::compareThreeWay() does not allow mixed-sign comparison.");#ifdef __cpp_lib_three_way_comparisonreturn lhs <=> rhs;#elseif(lhs == rhs)returnQt::strong_ordering::equivalent;else if(lhs < rhs)returnQt::strong_ordering::less;elsereturnQt::strong_ordering::greater;#endif// __cpp_lib_three_way_comparison}template<typename LeftFloat, typename RightFloat, if_floating_point<LeftFloat> =true, if_floating_point<RightFloat> =true>constexpr Qt::partial_ordering compareThreeWay(LeftFloat lhs, RightFloat rhs) noexcept { QT_WARNING_PUSH QT_WARNING_DISABLE_FLOAT_COMPARE #ifdef __cpp_lib_three_way_comparisonreturn lhs <=> rhs;#elseif(lhs < rhs)returnQt::partial_ordering::less;else if(lhs > rhs)returnQt::partial_ordering::greater;else if(lhs == rhs)returnQt::partial_ordering::equivalent;elsereturnQt::partial_ordering::unordered;#endif// __cpp_lib_three_way_comparisonQT_WARNING_POP }template<typename IntType, typename FloatType, if_integral<IntType> =true, if_floating_point<FloatType> =true>constexpr Qt::partial_ordering compareThreeWay(IntType lhs, FloatType rhs) noexcept {returncompareThreeWay(FloatType(lhs), rhs);}template<typename FloatType, typename IntType, if_floating_point<FloatType> =true, if_integral<IntType> =true>constexpr Qt::partial_ordering compareThreeWay(FloatType lhs, IntType rhs) noexcept {returncompareThreeWay(lhs,FloatType(rhs));}#if QT_DEPRECATED_SINCE(6, 8)template<typename LeftType, typename RightType, if_compatible_pointers<LeftType, RightType> =true>QT_DEPRECATED_VERSION_X_6_8("Wrap the pointers into Qt::totally_ordered_wrapper and use the respective overload instead.")constexpr Qt::strong_ordering compareThreeWay(const LeftType *lhs,const RightType *rhs) noexcept {#ifdef __cpp_lib_three_way_comparisonreturnstd::compare_three_way{}(lhs, rhs);#elseif(lhs == rhs)returnQt::strong_ordering::equivalent;else if(std::less<>{}(lhs, rhs))returnQt::strong_ordering::less;elsereturnQt::strong_ordering::greater;#endif// __cpp_lib_three_way_comparison}template<typename T>QT_DEPRECATED_VERSION_X_6_8("Wrap the pointer into Qt::totally_ordered_wrapper and use the respective overload instead.")constexpr Qt::strong_ordering compareThreeWay(const T *lhs,std::nullptr_t rhs) noexcept {returncompareThreeWay(lhs,static_cast<const T *>(rhs));}template<typename T>QT_DEPRECATED_VERSION_X_6_8("Wrap the pointer into Qt::totally_ordered_wrapper and use the respective overload instead.")constexpr Qt::strong_ordering compareThreeWay(std::nullptr_t lhs,const T *rhs) noexcept {returncompareThreeWay(static_cast<const T *>(lhs), rhs);}#endif// QT_DEPRECATED_SINCE(6, 8)template<class Enum, if_enum<Enum> =true>constexpr Qt::strong_ordering compareThreeWay(Enum lhs, Enum rhs) noexcept {returncompareThreeWay(qToUnderlying(lhs),qToUnderlying(rhs));}}// namespace Qtnamespace QtOrderingPrivate {template<typename Head, typename...Tail,std::size_t...Is>constexpr std::tuple<Tail...>qt_tuple_pop_front_impl(conststd::tuple<Head, Tail...> &t,std::index_sequence<Is...>) noexcept {returnstd::tuple<Tail...>(std::get<Is +1>(t)...);}template<typename Head, typename...Tail>constexpr std::tuple<Tail...>qt_tuple_pop_front(conststd::tuple<Head, Tail...> &t) noexcept {returnqt_tuple_pop_front_impl(t,std::index_sequence_for<Tail...>{});}template<typename LhsHead, typename...LhsTail, typename RhsHead, typename...RhsTail>constexpr autocompareThreeWayMulti(conststd::tuple<LhsHead, LhsTail...> &lhs,// ie. not emptyconststd::tuple<RhsHead, RhsTail...> &rhs) noexcept {static_assert(sizeof...(LhsTail) ==sizeof...(RhsTail),// expanded together below, but provide a nicer error message:"The tuple arguments have to have the same size.");usingQt::compareThreeWay;using R =std::common_type_t<decltype(compareThreeWay(std::declval<LhsHead>(),std::declval<RhsHead>())),decltype(compareThreeWay(std::declval<LhsTail>(),std::declval<RhsTail>()))...>;constauto&l =std::get<0>(lhs);constauto&r =std::get<0>(rhs);static_assert(noexcept(compareThreeWay(l, r)),"This function requires all relational operators to be noexcept.");constauto res =compareThreeWay(l, r);ifconstexpr(sizeof...(LhsTail) >0) {if(is_eq(res))return R{compareThreeWayMulti(qt_tuple_pop_front(lhs),qt_tuple_pop_front(rhs))};}return R{res};}}//QtOrderingPrivatenamespace Qt {// A wrapper class that adapts the wrappee to use the strongly-ordered// <functional> function objects for implementing the relational operators.// Mostly useful to avoid UB on pointers (which it currently mandates P to be),// because all the comparison helpers (incl. std::compare_three_way on// std::tuple<T*>!) will use the language-level operators.//template<typename P>class totally_ordered_wrapper {static_assert(std::is_pointer_v<P>);using T =std::remove_pointer_t<P>; P ptr;public:totally_ordered_wrapper() noexcept =default; Q_IMPLICIT constexprtotally_ordered_wrapper(std::nullptr_t)// requires std::is_pointer_v<P>:totally_ordered_wrapper(P{nullptr}) {}explicit constexprtotally_ordered_wrapper(P p) noexcept :ptr(p) {}constexpr P get()const noexcept {return ptr; }constexprvoidreset(P p) noexcept { ptr = p; }constexpr P operator->()const noexcept {returnget(); }template<typename U = T,std::enable_if_t<!std::is_void_v<U>,bool> =true>constexpr U &operator*()const noexcept {return*get(); }explicit constexpr operatorbool()const noexcept {returnget(); }private:// TODO: Replace the constraints with std::common_type_t<P, U> when// a bug in VxWorks is fixed!template<typename T, typename U>using if_compatible_types =std::enable_if_t<std::conjunction_v<std::is_pointer<T>,std::is_pointer<U>,std::disjunction<std::is_convertible<T, U>,std::is_convertible<U, T>>>,bool>;#define MAKE_RELOP(Ret, op, Op) \ template <typename U = P, if_compatible_types<P, U> = true> \ friend constexpr Ret operator op (const totally_ordered_wrapper<P> &lhs, const totally_ordered_wrapper<U> &rhs) noexcept \ { return std:: Op {}(lhs.ptr, rhs.get()); } \ template <typename U = P, if_compatible_types<P, U> = true> \ friend constexpr Ret operator op (const totally_ordered_wrapper<P> &lhs, const U &rhs) noexcept \ { return std:: Op {}(lhs.ptr, rhs ); } \ template <typename U = P, if_compatible_types<P, U> = true> \ friend constexpr Ret operator op (const U &lhs, const totally_ordered_wrapper<P> &rhs) noexcept \ { return std:: Op {}(lhs, rhs.ptr); } \ friend constexpr Ret operator op (const totally_ordered_wrapper &lhs, std::nullptr_t) noexcept \ { return std:: Op {}(lhs.ptr, P(nullptr)); } \ friend constexpr Ret operator op (std::nullptr_t, const totally_ordered_wrapper &rhs) noexcept \ { return std:: Op {}(P(nullptr), rhs.ptr); } \/* end */MAKE_RELOP(bool, ==, equal_to<>)MAKE_RELOP(bool, !=, not_equal_to<>)MAKE_RELOP(bool, < , less<>)MAKE_RELOP(bool, <=, less_equal<>)MAKE_RELOP(bool, > , greater<>)MAKE_RELOP(bool, >=, greater_equal<>)#ifdef __cpp_lib_three_way_comparisonMAKE_RELOP(auto, <=>, compare_three_way)#endif#undef MAKE_RELOPfriendvoidqt_ptr_swap(totally_ordered_wrapper &lhs, totally_ordered_wrapper &rhs) noexcept {qt_ptr_swap(lhs.ptr, rhs.ptr); }friendvoidswap(totally_ordered_wrapper &lhs, totally_ordered_wrapper &rhs) noexcept {qt_ptr_swap(lhs, rhs); }friendsize_tqHash(totally_ordered_wrapper key,size_t seed =0) noexcept {returnqHash(key.ptr, seed); }};template<typename T, typename U, if_compatible_pointers<T, U> =true>constexpr Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T*> lhs,Qt::totally_ordered_wrapper<U*> rhs) noexcept {returnQtOrderingPrivate::strongOrderingCompareDefaultImpl(lhs, rhs);}template<typename T, typename U, if_compatible_pointers<T, U> =true>constexpr Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T*> lhs, U *rhs) noexcept {returnQtOrderingPrivate::strongOrderingCompareDefaultImpl(lhs, rhs);}template<typename T, typename U, if_compatible_pointers<T, U> =true>constexpr Qt::strong_ordering compareThreeWay(U *lhs,Qt::totally_ordered_wrapper<T*> rhs) noexcept {returnQtOrderingPrivate::strongOrderingCompareDefaultImpl(lhs, rhs);}template<typename T>constexpr Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T*> lhs,std::nullptr_t rhs) noexcept {returnQtOrderingPrivate::strongOrderingCompareDefaultImpl(lhs, rhs);}template<typename T>constexpr Qt::strong_ordering compareThreeWay(std::nullptr_t lhs,Qt::totally_ordered_wrapper<T*> rhs) noexcept {returnQtOrderingPrivate::strongOrderingCompareDefaultImpl(lhs, rhs);}}//Qttemplate<typename P>class QTypeInfo<Qt::totally_ordered_wrapper<P>> :public QTypeInfo<P> {};namespace QtOrderingPrivate { QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED // don't warn _here_ in case we hit the deprecated ptr/ptr overloadsnamespace CompareThreeWayTester {usingQt::compareThreeWay;template<typename T>using WrappedType =std::conditional_t<std::is_pointer_v<T>,Qt::totally_ordered_wrapper<T>, T>;// Check if compareThreeWay is implemented for the (LT, RT) argument// pair.template<typename LT, typename RT, typename =void>struct HasCompareThreeWay :std::false_type {};template<typename LT, typename RT>struct HasCompareThreeWay< LT, RT,std::void_t<decltype(compareThreeWay(std::declval<LT>(),std::declval<RT>()))>> :std::true_type {};template<typename LT, typename RT>struct HasCompareThreeWay< LT*, RT*,std::void_t<decltype(compareThreeWay(std::declval<WrappedType<LT>>(),std::declval<WrappedType<RT>>()))>> :std::true_type {};template<typename LT, typename RT>constexpr inlinebool hasCompareThreeWay_v = HasCompareThreeWay<LT, RT>::value;// Check if the operation is noexcept. We have two different overloads,// depending on the available compareThreeWay() implementation.// Both are declared, but not implemented. To be used only in unevaluated// context.template<typename LT, typename RT,std::enable_if_t<hasCompareThreeWay_v<LT, RT>,bool> =true>constexprboolcompareThreeWayNoexcept() noexcept {returnnoexcept(compareThreeWay(std::declval<LT>(),std::declval<RT>())); }template<typename LT, typename RT,std::enable_if_t<std::conjunction_v<std::negation<HasCompareThreeWay<LT, RT>>, HasCompareThreeWay<RT, LT>>,bool> =true>constexprboolcompareThreeWayNoexcept() noexcept {returnnoexcept(compareThreeWay(std::declval<RT>(),std::declval<LT>())); }}// namespace CompareThreeWayTester QT_WARNING_POP // QT_WARNING_DISABLE_DEPRECATED#ifdef __cpp_lib_three_way_comparison[[maybe_unused]]inline constexprstruct{/* Niebloid */template<typename LT, typename RT = LT>[[maybe_unused]]constexpr auto operator()(const LT &lhs,const RT &rhs)const{// like [expos.only.entity]/2ifconstexpr(QTypeTraits::has_operator_compare_three_way_with_v<LT, RT>) {return lhs <=> rhs;}else{if(lhs < rhs)returnstd::weak_ordering::less;if(rhs < lhs)returnstd::weak_ordering::greater;returnstd::weak_ordering::equivalent;}}} synthThreeWay;template<typename Container, typename T>using if_has_op_less_or_op_compare_three_way =std::enable_if_t<std::disjunction_v<QTypeTraits::has_operator_less_than_container<Container, T>,QTypeTraits::has_operator_compare_three_way<T>>,bool>;#endif// __cpp_lib_three_way_comparison// These checks do not use Qt::compareThreeWay(), so only work for user-defined// compareThreeWay() helper functions.// We cannot use the same condition as in CompareThreeWayTester::hasCompareThreeWay,// because GCC seems to cache and re-use the result.// Created https://gcc.gnu.org/bugzilla/show_bug.cgi?id=117174// For now, modify the condition a bit without changing its meaning.template<typename LT, typename RT = LT, typename =void>struct HasCustomCompareThreeWay :std::false_type {};template<typename LT, typename RT>struct HasCustomCompareThreeWay< LT, RT,std::void_t<decltype(is_eq(compareThreeWay(std::declval<LT>(),std::declval<RT>())))>> :std::true_type {};template<typename InputIt1, typename InputIt2, typename Compare>autolexicographicalCompareThreeWay(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare cmp){using R =decltype(cmp(*first1, *first2));while(first1 != last1) {if(first2 == last2)returnR::greater;constauto r =cmp(*first1, *first2);if(is_neq(r))return r;++first1;++first2;}return first2 == last2 ?R::equivalent :R::less;}template<typename InputIt1, typename InputIt2>autolexicographicalCompareThreeWay(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2){using LT = typename std::iterator_traits<InputIt1>::value_type;using RT = typename std::iterator_traits<InputIt2>::value_type;// if LT && RT are pointers, and there is no user-defined compareThreeWay()// operation for the pointers, we need to wrap them into// Qt::totally_ordered_wrapper.constexprbool UseWrapper =std::conjunction_v<std::is_pointer<LT>,std::is_pointer<RT>,std::negation<HasCustomCompareThreeWay<LT, RT>>,std::negation<HasCustomCompareThreeWay<RT, LT>>>;using WrapLT =std::conditional_t<UseWrapper,Qt::totally_ordered_wrapper<LT>,const LT &>;using WrapRT =std::conditional_t<UseWrapper,Qt::totally_ordered_wrapper<RT>,const RT &>;auto cmp = [](LT const&lhs, RT const&rhs) {usingQt::compareThreeWay;namespace Test =QtOrderingPrivate::CompareThreeWayTester;// Need this because the user might provide only// compareThreeWay(LT, RT), but not the reversed version.ifconstexpr(Test::hasCompareThreeWay_v<WrapLT, WrapRT>)returncompareThreeWay(WrapLT(lhs),WrapRT(rhs));elsereturnQtOrderingPrivate::reversed(compareThreeWay(WrapRT(rhs),WrapLT(lhs)));};returnlexicographicalCompareThreeWay(first1, last1, first2, last2, cmp);}}// namespace QtOrderingPrivatenamespace Qt {template<typename T, typename U>using if_has_qt_compare_three_way =std::enable_if_t<std::disjunction_v<QtOrderingPrivate::CompareThreeWayTester::HasCompareThreeWay<T, U>,QtOrderingPrivate::CompareThreeWayTester::HasCompareThreeWay<U, T>>,bool>;}// namespace Qt QT_END_NAMESPACE namespace std {template<typename P>struct hash<QT_PREPEND_NAMESPACE(Qt::totally_ordered_wrapper)<P>>{using argument_type =QT_PREPEND_NAMESPACE(Qt::totally_ordered_wrapper)<P>;using result_type =size_t;constexpr result_type operator()(argument_type w)const noexcept {returnstd::hash<P>{}(w.get()); }};}#endif// QCOMPAREHELPERS_H