Rename Q*Ordering to Qt::*_ordering
Since we cannot re-use the pre-existing QPartialOrdering type due to
binary-compatibility issues (it's not BC to std::partial_ordering),
we're no longer bound to copy its API for consistency.
So copy std::*_ordering type API for consistency instead, to ease
porting for users that can already use C++20 and everyone else come
Qt 7.
This patch is another step in that direction, renaming classes and
their memmbers to std-compatible names. QPartialOrdering cannot
change, as it's pre-existing. So add a completely new type
Qt::partial_ordering.
Adding conversions from QPartialOrdering is left for a follow-up
patch.
As a drive-by, change `\c Less` to `\l Less` in the \class
documentation blocks of the new classes.
Amending c6fe64b17c, which didn't have a
ChangeLog:
[ChangeLog][QtCore] Added Qt::{partial,weak,strong}_ordering as
drop-in C++17 stand-ins for C++20's std::{partial,weak,strong}_ordering.
Task-number: QTBUG-119108
Change-Id: Ib1296de6b708571a6abca8843ba36c114f6fd34f
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
This commit is contained in:
Marc Mutz
parent
67072a70af
commit
bdd41f491c
@ -142,9 +142,6 @@ public:
|
||||
#endif // __cpp_lib_three_way_comparison
|
||||
|
||||
private:
|
||||
friend class QWeakOrdering;
|
||||
friend class QStrongOrdering;
|
||||
|
||||
constexpr explicit QPartialOrdering(QtPrivate::Ordering order) noexcept
|
||||
: m_order(static_cast<QtPrivate::CompareUnderlyingType>(order))
|
||||
{}
|
||||
@ -176,86 +173,226 @@ inline constexpr QPartialOrdering QPartialOrdering::Equivalent(QtPrivate::Orderi
|
||||
inline constexpr QPartialOrdering QPartialOrdering::Greater(QtPrivate::Ordering::Greater);
|
||||
inline constexpr QPartialOrdering QPartialOrdering::Unordered(QtPrivate::Uncomparable::Unordered);
|
||||
|
||||
class QWeakOrdering
|
||||
namespace Qt {
|
||||
|
||||
class partial_ordering
|
||||
{
|
||||
public:
|
||||
static const QWeakOrdering Less;
|
||||
static const QWeakOrdering Equivalent;
|
||||
static const QWeakOrdering Greater;
|
||||
static const partial_ordering less;
|
||||
static const partial_ordering equivalent;
|
||||
static const partial_ordering greater;
|
||||
static const partial_ordering unordered;
|
||||
|
||||
constexpr Q_IMPLICIT operator QPartialOrdering() const noexcept
|
||||
{ return QPartialOrdering(static_cast<QtPrivate::Ordering>(m_order)); }
|
||||
friend constexpr bool operator==(partial_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.isOrdered() && lhs.m_order == 0; }
|
||||
|
||||
friend constexpr bool operator==(QWeakOrdering lhs,
|
||||
friend constexpr bool operator!=(partial_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.isOrdered() && lhs.m_order != 0; }
|
||||
|
||||
friend constexpr bool operator< (partial_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.isOrdered() && lhs.m_order < 0; }
|
||||
|
||||
friend constexpr bool operator<=(partial_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.isOrdered() && lhs.m_order <= 0; }
|
||||
|
||||
friend constexpr bool operator> (partial_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.isOrdered() && lhs.m_order > 0; }
|
||||
|
||||
friend constexpr bool operator>=(partial_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.isOrdered() && lhs.m_order >= 0; }
|
||||
|
||||
|
||||
friend constexpr bool operator==(QtPrivate::CompareAgainstLiteralZero,
|
||||
partial_ordering rhs) noexcept
|
||||
{ return rhs.isOrdered() && 0 == rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator!=(QtPrivate::CompareAgainstLiteralZero,
|
||||
partial_ordering rhs) noexcept
|
||||
{ return rhs.isOrdered() && 0 != rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator< (QtPrivate::CompareAgainstLiteralZero,
|
||||
partial_ordering rhs) noexcept
|
||||
{ return rhs.isOrdered() && 0 < rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator<=(QtPrivate::CompareAgainstLiteralZero,
|
||||
partial_ordering rhs) noexcept
|
||||
{ return rhs.isOrdered() && 0 <= rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator> (QtPrivate::CompareAgainstLiteralZero,
|
||||
partial_ordering rhs) noexcept
|
||||
{ return rhs.isOrdered() && 0 > rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator>=(QtPrivate::CompareAgainstLiteralZero,
|
||||
partial_ordering rhs) noexcept
|
||||
{ return rhs.isOrdered() && 0 >= rhs.m_order; }
|
||||
|
||||
|
||||
friend constexpr bool operator==(partial_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return lhs.m_order == rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator!=(partial_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return lhs.m_order != rhs.m_order; }
|
||||
|
||||
#ifdef __cpp_lib_three_way_comparison
|
||||
constexpr Q_IMPLICIT partial_ordering(std::partial_ordering stdorder) noexcept
|
||||
{
|
||||
if (stdorder == std::partial_ordering::less)
|
||||
m_order = static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Ordering::Less);
|
||||
else if (stdorder == std::partial_ordering::equivalent)
|
||||
m_order = static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Ordering::Equivalent);
|
||||
else if (stdorder == std::partial_ordering::greater)
|
||||
m_order = static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Ordering::Greater);
|
||||
else if (stdorder == std::partial_ordering::unordered)
|
||||
m_order = static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Uncomparable::Unordered);
|
||||
}
|
||||
|
||||
constexpr Q_IMPLICIT operator std::partial_ordering() const noexcept
|
||||
{
|
||||
if (static_cast<QtPrivate::Ordering>(m_order) == QtPrivate::Ordering::Less)
|
||||
return std::partial_ordering::less;
|
||||
else if (static_cast<QtPrivate::Ordering>(m_order) == QtPrivate::Ordering::Equivalent)
|
||||
return std::partial_ordering::equivalent;
|
||||
else if (static_cast<QtPrivate::Ordering>(m_order) == QtPrivate::Ordering::Greater)
|
||||
return std::partial_ordering::greater;
|
||||
else if (static_cast<QtPrivate::Uncomparable>(m_order) == QtPrivate::Uncomparable::Unordered)
|
||||
return std::partial_ordering::unordered;
|
||||
return std::partial_ordering::unordered;
|
||||
}
|
||||
|
||||
friend constexpr bool operator==(partial_ordering lhs, std::partial_ordering rhs) noexcept
|
||||
{ return static_cast<std::partial_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(partial_ordering lhs, std::partial_ordering rhs) noexcept
|
||||
{ return static_cast<std::partial_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(std::partial_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<std::partial_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(std::partial_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<std::partial_ordering>(rhs); }
|
||||
#endif // __cpp_lib_three_way_comparison
|
||||
|
||||
private:
|
||||
friend class weak_ordering;
|
||||
friend class strong_ordering;
|
||||
|
||||
constexpr explicit partial_ordering(QtPrivate::Ordering order) noexcept
|
||||
: m_order(static_cast<QtPrivate::CompareUnderlyingType>(order))
|
||||
{}
|
||||
constexpr explicit partial_ordering(QtPrivate::Uncomparable order) noexcept
|
||||
: m_order(static_cast<QtPrivate::CompareUnderlyingType>(order))
|
||||
{}
|
||||
|
||||
QT_WARNING_PUSH
|
||||
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100903
|
||||
QT_WARNING_DISABLE_GCC("-Wzero-as-null-pointer-constant")
|
||||
friend constexpr bool is_eq (partial_ordering o) noexcept { return o == 0; }
|
||||
friend constexpr bool is_neq (partial_ordering o) noexcept { return o != 0; }
|
||||
friend constexpr bool is_lt (partial_ordering o) noexcept { return o < 0; }
|
||||
friend constexpr bool is_lteq(partial_ordering o) noexcept { return o <= 0; }
|
||||
friend constexpr bool is_gt (partial_ordering o) noexcept { return o > 0; }
|
||||
friend constexpr bool is_gteq(partial_ordering o) noexcept { return o >= 0; }
|
||||
QT_WARNING_POP
|
||||
|
||||
// instead of the exposition only is_ordered member in [cmp.partialord],
|
||||
// use a private function
|
||||
constexpr bool isOrdered() const noexcept
|
||||
{ return m_order != static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Uncomparable::Unordered); }
|
||||
|
||||
QtPrivate::CompareUnderlyingType m_order;
|
||||
};
|
||||
|
||||
inline constexpr partial_ordering partial_ordering::less(QtPrivate::Ordering::Less);
|
||||
inline constexpr partial_ordering partial_ordering::equivalent(QtPrivate::Ordering::Equivalent);
|
||||
inline constexpr partial_ordering partial_ordering::greater(QtPrivate::Ordering::Greater);
|
||||
inline constexpr partial_ordering partial_ordering::unordered(QtPrivate::Uncomparable::Unordered);
|
||||
|
||||
class weak_ordering
|
||||
{
|
||||
public:
|
||||
static const weak_ordering less;
|
||||
static const weak_ordering equivalent;
|
||||
static const weak_ordering greater;
|
||||
|
||||
constexpr Q_IMPLICIT operator partial_ordering() const noexcept
|
||||
{ return partial_ordering(static_cast<QtPrivate::Ordering>(m_order)); }
|
||||
|
||||
friend constexpr bool operator==(weak_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order == 0; }
|
||||
|
||||
friend constexpr bool operator!=(QWeakOrdering lhs,
|
||||
friend constexpr bool operator!=(weak_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order != 0; }
|
||||
|
||||
friend constexpr bool operator< (QWeakOrdering lhs,
|
||||
friend constexpr bool operator< (weak_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order < 0; }
|
||||
|
||||
friend constexpr bool operator<=(QWeakOrdering lhs,
|
||||
friend constexpr bool operator<=(weak_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order <= 0; }
|
||||
|
||||
friend constexpr bool operator> (QWeakOrdering lhs,
|
||||
friend constexpr bool operator> (weak_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order > 0; }
|
||||
|
||||
friend constexpr bool operator>=(QWeakOrdering lhs,
|
||||
friend constexpr bool operator>=(weak_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order >= 0; }
|
||||
|
||||
|
||||
friend constexpr bool operator==(QtPrivate::CompareAgainstLiteralZero,
|
||||
QWeakOrdering rhs) noexcept
|
||||
weak_ordering rhs) noexcept
|
||||
{ return 0 == rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator!=(QtPrivate::CompareAgainstLiteralZero,
|
||||
QWeakOrdering rhs) noexcept
|
||||
weak_ordering rhs) noexcept
|
||||
{ return 0 != rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator< (QtPrivate::CompareAgainstLiteralZero,
|
||||
QWeakOrdering rhs) noexcept
|
||||
weak_ordering rhs) noexcept
|
||||
{ return 0 < rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator<=(QtPrivate::CompareAgainstLiteralZero,
|
||||
QWeakOrdering rhs) noexcept
|
||||
weak_ordering rhs) noexcept
|
||||
{ return 0 <= rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator> (QtPrivate::CompareAgainstLiteralZero,
|
||||
QWeakOrdering rhs) noexcept
|
||||
weak_ordering rhs) noexcept
|
||||
{ return 0 > rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator>=(QtPrivate::CompareAgainstLiteralZero,
|
||||
QWeakOrdering rhs) noexcept
|
||||
weak_ordering rhs) noexcept
|
||||
{ return 0 >= rhs.m_order; }
|
||||
|
||||
|
||||
friend constexpr bool operator==(QWeakOrdering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(weak_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs.m_order == rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator!=(QWeakOrdering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(weak_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs.m_order != rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator==(QWeakOrdering lhs, QPartialOrdering rhs) noexcept
|
||||
{ return static_cast<QPartialOrdering>(lhs) == rhs; }
|
||||
friend constexpr bool operator==(weak_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return static_cast<partial_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QWeakOrdering lhs, QPartialOrdering rhs) noexcept
|
||||
{ return static_cast<QPartialOrdering>(lhs) != rhs; }
|
||||
friend constexpr bool operator!=(weak_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return static_cast<partial_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(QPartialOrdering lhs, QWeakOrdering rhs) noexcept
|
||||
{ return lhs == static_cast<QPartialOrdering>(rhs); }
|
||||
friend constexpr bool operator==(partial_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<partial_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(QPartialOrdering lhs, QWeakOrdering rhs) noexcept
|
||||
{ return lhs != static_cast<QPartialOrdering>(rhs); }
|
||||
friend constexpr bool operator!=(partial_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<partial_ordering>(rhs); }
|
||||
|
||||
#ifdef __cpp_lib_three_way_comparison
|
||||
constexpr Q_IMPLICIT QWeakOrdering(std::weak_ordering stdorder) noexcept
|
||||
constexpr Q_IMPLICIT weak_ordering(std::weak_ordering stdorder) noexcept
|
||||
{
|
||||
if (stdorder == std::weak_ordering::less)
|
||||
m_order = static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Ordering::Less);
|
||||
@ -276,164 +413,164 @@ public:
|
||||
return std::weak_ordering::equivalent;
|
||||
}
|
||||
|
||||
friend constexpr bool operator==(QWeakOrdering lhs, std::weak_ordering rhs) noexcept
|
||||
friend constexpr bool operator==(weak_ordering lhs, std::weak_ordering rhs) noexcept
|
||||
{ return static_cast<std::weak_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QWeakOrdering lhs, std::weak_ordering rhs) noexcept
|
||||
friend constexpr bool operator!=(weak_ordering lhs, std::weak_ordering rhs) noexcept
|
||||
{ return static_cast<std::weak_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(QWeakOrdering lhs, std::partial_ordering rhs) noexcept
|
||||
friend constexpr bool operator==(weak_ordering lhs, std::partial_ordering rhs) noexcept
|
||||
{ return static_cast<std::weak_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QWeakOrdering lhs, std::partial_ordering rhs) noexcept
|
||||
friend constexpr bool operator!=(weak_ordering lhs, std::partial_ordering rhs) noexcept
|
||||
{ return static_cast<std::weak_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(QWeakOrdering lhs, std::strong_ordering rhs) noexcept
|
||||
friend constexpr bool operator==(weak_ordering lhs, std::strong_ordering rhs) noexcept
|
||||
{ return static_cast<std::weak_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QWeakOrdering lhs, std::strong_ordering rhs) noexcept
|
||||
friend constexpr bool operator!=(weak_ordering lhs, std::strong_ordering rhs) noexcept
|
||||
{ return static_cast<std::weak_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(std::weak_ordering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(std::weak_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<std::weak_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(std::weak_ordering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(std::weak_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<std::weak_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator==(std::partial_ordering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(std::partial_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<std::weak_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(std::partial_ordering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(std::partial_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<std::weak_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator==(std::strong_ordering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(std::strong_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<std::weak_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(std::strong_ordering lhs, QWeakOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(std::strong_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<std::weak_ordering>(rhs); }
|
||||
#endif // __cpp_lib_three_way_comparison
|
||||
|
||||
private:
|
||||
friend class QStrongOrdering;
|
||||
friend class strong_ordering;
|
||||
|
||||
constexpr explicit QWeakOrdering(QtPrivate::Ordering order) noexcept
|
||||
constexpr explicit weak_ordering(QtPrivate::Ordering order) noexcept
|
||||
: m_order(static_cast<QtPrivate::CompareUnderlyingType>(order))
|
||||
{}
|
||||
|
||||
QT_WARNING_PUSH
|
||||
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100903
|
||||
QT_WARNING_DISABLE_GCC("-Wzero-as-null-pointer-constant")
|
||||
friend constexpr bool is_eq (QWeakOrdering o) noexcept { return o == 0; }
|
||||
friend constexpr bool is_neq (QWeakOrdering o) noexcept { return o != 0; }
|
||||
friend constexpr bool is_lt (QWeakOrdering o) noexcept { return o < 0; }
|
||||
friend constexpr bool is_lteq(QWeakOrdering o) noexcept { return o <= 0; }
|
||||
friend constexpr bool is_gt (QWeakOrdering o) noexcept { return o > 0; }
|
||||
friend constexpr bool is_gteq(QWeakOrdering o) noexcept { return o >= 0; }
|
||||
friend constexpr bool is_eq (weak_ordering o) noexcept { return o == 0; }
|
||||
friend constexpr bool is_neq (weak_ordering o) noexcept { return o != 0; }
|
||||
friend constexpr bool is_lt (weak_ordering o) noexcept { return o < 0; }
|
||||
friend constexpr bool is_lteq(weak_ordering o) noexcept { return o <= 0; }
|
||||
friend constexpr bool is_gt (weak_ordering o) noexcept { return o > 0; }
|
||||
friend constexpr bool is_gteq(weak_ordering o) noexcept { return o >= 0; }
|
||||
QT_WARNING_POP
|
||||
|
||||
QtPrivate::CompareUnderlyingType m_order;
|
||||
};
|
||||
|
||||
inline constexpr QWeakOrdering QWeakOrdering::Less(QtPrivate::Ordering::Less);
|
||||
inline constexpr QWeakOrdering QWeakOrdering::Equivalent(QtPrivate::Ordering::Equivalent);
|
||||
inline constexpr QWeakOrdering QWeakOrdering::Greater(QtPrivate::Ordering::Greater);
|
||||
inline constexpr weak_ordering weak_ordering::less(QtPrivate::Ordering::Less);
|
||||
inline constexpr weak_ordering weak_ordering::equivalent(QtPrivate::Ordering::Equivalent);
|
||||
inline constexpr weak_ordering weak_ordering::greater(QtPrivate::Ordering::Greater);
|
||||
|
||||
class QStrongOrdering
|
||||
class strong_ordering
|
||||
{
|
||||
public:
|
||||
static const QStrongOrdering Less;
|
||||
static const QStrongOrdering Equivalent;
|
||||
static const QStrongOrdering Equal;
|
||||
static const QStrongOrdering Greater;
|
||||
static const strong_ordering less;
|
||||
static const strong_ordering equivalent;
|
||||
static const strong_ordering equal;
|
||||
static const strong_ordering greater;
|
||||
|
||||
constexpr Q_IMPLICIT operator QPartialOrdering() const noexcept
|
||||
{ return QPartialOrdering(static_cast<QtPrivate::Ordering>(m_order)); }
|
||||
constexpr Q_IMPLICIT operator partial_ordering() const noexcept
|
||||
{ return partial_ordering(static_cast<QtPrivate::Ordering>(m_order)); }
|
||||
|
||||
constexpr Q_IMPLICIT operator QWeakOrdering() const noexcept
|
||||
{ return QWeakOrdering(static_cast<QtPrivate::Ordering>(m_order)); }
|
||||
constexpr Q_IMPLICIT operator weak_ordering() const noexcept
|
||||
{ return weak_ordering(static_cast<QtPrivate::Ordering>(m_order)); }
|
||||
|
||||
friend constexpr bool operator==(QStrongOrdering lhs,
|
||||
friend constexpr bool operator==(strong_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order == 0; }
|
||||
|
||||
friend constexpr bool operator!=(QStrongOrdering lhs,
|
||||
friend constexpr bool operator!=(strong_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order != 0; }
|
||||
|
||||
friend constexpr bool operator< (QStrongOrdering lhs,
|
||||
friend constexpr bool operator< (strong_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order < 0; }
|
||||
|
||||
friend constexpr bool operator<=(QStrongOrdering lhs,
|
||||
friend constexpr bool operator<=(strong_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order <= 0; }
|
||||
|
||||
friend constexpr bool operator> (QStrongOrdering lhs,
|
||||
friend constexpr bool operator> (strong_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order > 0; }
|
||||
|
||||
friend constexpr bool operator>=(QStrongOrdering lhs,
|
||||
friend constexpr bool operator>=(strong_ordering lhs,
|
||||
QtPrivate::CompareAgainstLiteralZero) noexcept
|
||||
{ return lhs.m_order >= 0; }
|
||||
|
||||
|
||||
friend constexpr bool operator==(QtPrivate::CompareAgainstLiteralZero,
|
||||
QStrongOrdering rhs) noexcept
|
||||
strong_ordering rhs) noexcept
|
||||
{ return 0 == rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator!=(QtPrivate::CompareAgainstLiteralZero,
|
||||
QStrongOrdering rhs) noexcept
|
||||
strong_ordering rhs) noexcept
|
||||
{ return 0 != rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator< (QtPrivate::CompareAgainstLiteralZero,
|
||||
QStrongOrdering rhs) noexcept
|
||||
strong_ordering rhs) noexcept
|
||||
{ return 0 < rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator<=(QtPrivate::CompareAgainstLiteralZero,
|
||||
QStrongOrdering rhs) noexcept
|
||||
strong_ordering rhs) noexcept
|
||||
{ return 0 <= rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator> (QtPrivate::CompareAgainstLiteralZero,
|
||||
QStrongOrdering rhs) noexcept
|
||||
strong_ordering rhs) noexcept
|
||||
{ return 0 > rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator>=(QtPrivate::CompareAgainstLiteralZero,
|
||||
QStrongOrdering rhs) noexcept
|
||||
strong_ordering rhs) noexcept
|
||||
{ return 0 >= rhs.m_order; }
|
||||
|
||||
|
||||
friend constexpr bool operator==(QStrongOrdering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(strong_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs.m_order == rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator!=(QStrongOrdering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(strong_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs.m_order != rhs.m_order; }
|
||||
|
||||
friend constexpr bool operator==(QStrongOrdering lhs, QPartialOrdering rhs) noexcept
|
||||
{ return static_cast<QPartialOrdering>(lhs) == rhs; }
|
||||
friend constexpr bool operator==(strong_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return static_cast<partial_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QStrongOrdering lhs, QPartialOrdering rhs) noexcept
|
||||
{ return static_cast<QPartialOrdering>(lhs) == rhs; }
|
||||
friend constexpr bool operator!=(strong_ordering lhs, partial_ordering rhs) noexcept
|
||||
{ return static_cast<partial_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator==(QPartialOrdering lhs, QStrongOrdering rhs) noexcept
|
||||
{ return lhs == static_cast<QPartialOrdering>(rhs); }
|
||||
friend constexpr bool operator==(partial_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<partial_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(QPartialOrdering lhs, QStrongOrdering rhs) noexcept
|
||||
{ return lhs != static_cast<QPartialOrdering>(rhs); }
|
||||
friend constexpr bool operator!=(partial_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<partial_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator==(QStrongOrdering lhs, QWeakOrdering rhs) noexcept
|
||||
{ return static_cast<QWeakOrdering>(lhs) == rhs; }
|
||||
friend constexpr bool operator==(strong_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return static_cast<weak_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QStrongOrdering lhs, QWeakOrdering rhs) noexcept
|
||||
{ return static_cast<QWeakOrdering>(lhs) == rhs; }
|
||||
friend constexpr bool operator!=(strong_ordering lhs, weak_ordering rhs) noexcept
|
||||
{ return static_cast<weak_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator==(QWeakOrdering lhs, QStrongOrdering rhs) noexcept
|
||||
{ return lhs == static_cast<QWeakOrdering>(rhs); }
|
||||
friend constexpr bool operator==(weak_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<weak_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(QWeakOrdering lhs, QStrongOrdering rhs) noexcept
|
||||
{ return lhs != static_cast<QWeakOrdering>(rhs); }
|
||||
friend constexpr bool operator!=(weak_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<weak_ordering>(rhs); }
|
||||
|
||||
#ifdef __cpp_lib_three_way_comparison
|
||||
constexpr Q_IMPLICIT QStrongOrdering(std::strong_ordering stdorder) noexcept
|
||||
constexpr Q_IMPLICIT strong_ordering(std::strong_ordering stdorder) noexcept
|
||||
{
|
||||
if (stdorder == std::strong_ordering::less)
|
||||
m_order = static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Ordering::Less);
|
||||
@ -458,66 +595,68 @@ public:
|
||||
return std::strong_ordering::equivalent;
|
||||
}
|
||||
|
||||
friend constexpr bool operator==(QStrongOrdering lhs, std::strong_ordering rhs) noexcept
|
||||
friend constexpr bool operator==(strong_ordering lhs, std::strong_ordering rhs) noexcept
|
||||
{ return static_cast<std::strong_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QStrongOrdering lhs, std::strong_ordering rhs) noexcept
|
||||
friend constexpr bool operator!=(strong_ordering lhs, std::strong_ordering rhs) noexcept
|
||||
{ return static_cast<std::strong_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(QStrongOrdering lhs, std::partial_ordering rhs) noexcept
|
||||
friend constexpr bool operator==(strong_ordering lhs, std::partial_ordering rhs) noexcept
|
||||
{ return static_cast<std::strong_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QStrongOrdering lhs, std::partial_ordering rhs) noexcept
|
||||
friend constexpr bool operator!=(strong_ordering lhs, std::partial_ordering rhs) noexcept
|
||||
{ return static_cast<std::strong_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(QStrongOrdering lhs, std::weak_ordering rhs) noexcept
|
||||
friend constexpr bool operator==(strong_ordering lhs, std::weak_ordering rhs) noexcept
|
||||
{ return static_cast<std::strong_ordering>(lhs) == rhs; }
|
||||
|
||||
friend constexpr bool operator!=(QStrongOrdering lhs, std::weak_ordering rhs) noexcept
|
||||
friend constexpr bool operator!=(strong_ordering lhs, std::weak_ordering rhs) noexcept
|
||||
{ return static_cast<std::strong_ordering>(lhs) != rhs; }
|
||||
|
||||
friend constexpr bool operator==(std::strong_ordering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(std::strong_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<std::strong_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(std::strong_ordering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(std::strong_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<std::strong_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator==(std::partial_ordering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(std::partial_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<std::strong_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(std::partial_ordering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(std::partial_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<std::strong_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator==(std::weak_ordering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator==(std::weak_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs == static_cast<std::strong_ordering>(rhs); }
|
||||
|
||||
friend constexpr bool operator!=(std::weak_ordering lhs, QStrongOrdering rhs) noexcept
|
||||
friend constexpr bool operator!=(std::weak_ordering lhs, strong_ordering rhs) noexcept
|
||||
{ return lhs != static_cast<std::strong_ordering>(rhs); }
|
||||
#endif // __cpp_lib_three_way_comparison
|
||||
|
||||
private:
|
||||
constexpr explicit QStrongOrdering(QtPrivate::Ordering order) noexcept
|
||||
constexpr explicit strong_ordering(QtPrivate::Ordering order) noexcept
|
||||
: m_order(static_cast<QtPrivate::CompareUnderlyingType>(order))
|
||||
{}
|
||||
|
||||
QT_WARNING_PUSH
|
||||
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100903
|
||||
QT_WARNING_DISABLE_GCC("-Wzero-as-null-pointer-constant")
|
||||
friend constexpr bool is_eq (QStrongOrdering o) noexcept { return o == 0; }
|
||||
friend constexpr bool is_neq (QStrongOrdering o) noexcept { return o != 0; }
|
||||
friend constexpr bool is_lt (QStrongOrdering o) noexcept { return o < 0; }
|
||||
friend constexpr bool is_lteq(QStrongOrdering o) noexcept { return o <= 0; }
|
||||
friend constexpr bool is_gt (QStrongOrdering o) noexcept { return o > 0; }
|
||||
friend constexpr bool is_gteq(QStrongOrdering o) noexcept { return o >= 0; }
|
||||
friend constexpr bool is_eq (strong_ordering o) noexcept { return o == 0; }
|
||||
friend constexpr bool is_neq (strong_ordering o) noexcept { return o != 0; }
|
||||
friend constexpr bool is_lt (strong_ordering o) noexcept { return o < 0; }
|
||||
friend constexpr bool is_lteq(strong_ordering o) noexcept { return o <= 0; }
|
||||
friend constexpr bool is_gt (strong_ordering o) noexcept { return o > 0; }
|
||||
friend constexpr bool is_gteq(strong_ordering o) noexcept { return o >= 0; }
|
||||
QT_WARNING_POP
|
||||
|
||||
QtPrivate::CompareUnderlyingType m_order;
|
||||
};
|
||||
|
||||
inline constexpr QStrongOrdering QStrongOrdering::Less(QtPrivate::Ordering::Less);
|
||||
inline constexpr QStrongOrdering QStrongOrdering::Equivalent(QtPrivate::Ordering::Equivalent);
|
||||
inline constexpr QStrongOrdering QStrongOrdering::Equal(QtPrivate::Ordering::Equal);
|
||||
inline constexpr QStrongOrdering QStrongOrdering::Greater(QtPrivate::Ordering::Greater);
|
||||
inline constexpr strong_ordering strong_ordering::less(QtPrivate::Ordering::Less);
|
||||
inline constexpr strong_ordering strong_ordering::equivalent(QtPrivate::Ordering::Equivalent);
|
||||
inline constexpr strong_ordering strong_ordering::equal(QtPrivate::Ordering::Equal);
|
||||
inline constexpr strong_ordering strong_ordering::greater(QtPrivate::Ordering::Greater);
|
||||
|
||||
} // namespace Qt
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
\title Comparison types overview
|
||||
\keyword three-way comparison
|
||||
\inmodule QtCore
|
||||
\sa QStrongOrdering, QWeakOrdering, QPartialOrdering
|
||||
\sa Qt::strong_ordering, Qt::weak_ordering, Qt::partial_ordering
|
||||
|
||||
\note Qt's comparison types provide functionality equivalent to their C++20
|
||||
standard counterparts. The only reason why they exist is to make the
|
||||
@ -35,49 +35,49 @@
|
||||
\row
|
||||
\li \l {https://en.cppreference.com/w/cpp/utility/compare/strong_ordering}
|
||||
{std::strong_ordering}
|
||||
\li QStrongOrdering
|
||||
\li Qt::strong_ordering
|
||||
\li yes
|
||||
\li yes
|
||||
\li integral types, case-sensitive strings, QDate, QTime
|
||||
\row
|
||||
\li \l {https://en.cppreference.com/w/cpp/utility/compare/weak_ordering}
|
||||
{std::weak_ordering}
|
||||
\li QWeakOrdering
|
||||
\li Qt::weak_ordering
|
||||
\li no
|
||||
\li yes
|
||||
\li case-insensitive strings, unordered associative containers, QDateTime
|
||||
\row
|
||||
\li \l {https://en.cppreference.com/w/cpp/utility/compare/partial_ordering}
|
||||
{std::partial_ordering}
|
||||
\li QPartialOrdering
|
||||
\li Qt::partial_ordering
|
||||
\li no
|
||||
\li no
|
||||
\li floating-point types, QOperatingSystemVersion, QVariant
|
||||
\endtable
|
||||
|
||||
The strongest comparison type, QStrongOrdering, represents a strict total
|
||||
The strongest comparison type, Qt::strong_ordering, represents a strict total
|
||||
order. It requires that any two elements be comparable in a way where
|
||||
equality implies substitutability. In other words, equivalent values
|
||||
cannot be distinguished from each other. A practical example would be the
|
||||
case-sensitive comparison of two strings. For instance, when comparing the
|
||||
values \c "Qt" and \c "Qt" the result would be \l QStrongOrdering::Equal.
|
||||
values \c "Qt" and \c "Qt" the result would be \l Qt::strong_ordering::equal.
|
||||
Both values are indistinguishable and all deterministic operations performed
|
||||
on these values would yield identical results.
|
||||
|
||||
QWeakOrdering represents a total order. While any two values still need to
|
||||
Qt::weak_ordering represents a total order. While any two values still need to
|
||||
be comparable, equivalent values may be distinguishable. The canonical
|
||||
example here would be the case-insensitive comparison of two strings. For
|
||||
instance, when comparing the values \c "Qt" and \c "qt" both hold the same
|
||||
letters but with different representations. This comparison would
|
||||
result in \l QWeakOrdering::Equivalent, but not actually \c Equal.
|
||||
result in \l Qt::weak_ordering::equivalent, but not actually \c Equal.
|
||||
Another example would be QDateTime, which can represent a given instant in
|
||||
time in terms of local time or any other time-zone, including UTC. The
|
||||
different representations are equivalent, even though their \c time() and
|
||||
sometimes \c date() may differ.
|
||||
|
||||
QPartialOrdering represents, as the name implies, a partial ordering. It
|
||||
Qt::partial_ordering represents, as the name implies, a partial ordering. It
|
||||
allows for the possibility that two values may not be comparable, resulting
|
||||
in an \l {QPartialOrdering::}{Unordered} state. Additionally, equivalent
|
||||
in an \l {Qt::partial_ordering::}{unordered} state. Additionally, equivalent
|
||||
values may still be distinguishable. A practical example would be the
|
||||
comparison of two floating-point values, comparing with NaN (Not-a-Number)
|
||||
would yield an unordered result. Another example is the comparison of two
|
||||
@ -91,29 +91,29 @@
|
||||
*/
|
||||
|
||||
/*!
|
||||
\class QStrongOrdering
|
||||
\class Qt::strong_ordering
|
||||
\inmodule QtCore
|
||||
\brief QStrongOrdering represents a comparison where equivalent values are
|
||||
\brief Qt::strong_ordering represents a comparison where equivalent values are
|
||||
indistinguishable.
|
||||
\sa QWeakOrdering, QPartialOrdering, {Comparison types overview}
|
||||
\sa Qt::weak_ordering, Qt::partial_ordering, {Comparison types overview}
|
||||
\since 6.7
|
||||
|
||||
A value of type QStrongOrdering is typically returned from a three-way
|
||||
A value of type Qt::strong_ordering is typically returned from a three-way
|
||||
comparison function. Such a function compares two objects and establishes
|
||||
that the two objects are in a strict ordering relationship; that is, the
|
||||
function establishes a well-defined total order.
|
||||
|
||||
The possible values of type QStrongOrdering are fully represented by the
|
||||
The possible values of type Qt::strong_ordering are fully represented by the
|
||||
following four symbolic constants:
|
||||
|
||||
\list
|
||||
\li \c Less represents that the left operand is less than the right;
|
||||
\li \c Equal represents that the left operand is equivalent to the right;
|
||||
\li \c Equivalent is an alias for \c Equal;
|
||||
\li \c Greater represents that the left operand is greater than the right.
|
||||
\li \l less represents that the left operand is less than the right;
|
||||
\li \l equal represents that the left operand is equivalent to the right;
|
||||
\li \l equivalent is an alias for \c Equal;
|
||||
\li \l greater represents that the left operand is greater than the right.
|
||||
\endlist
|
||||
|
||||
QStrongOrdering is idiomatically used by comparing an instance against a
|
||||
Qt::strong_ordering is idiomatically used by comparing an instance against a
|
||||
literal zero, for instance like this:
|
||||
|
||||
\code
|
||||
@ -121,10 +121,10 @@
|
||||
// given a, b, c, d as objects of some type that allows for a 3-way compare,
|
||||
// and a compare function declared as follows:
|
||||
|
||||
QStrongOrdering compare(T lhs, T rhs); // defined out-of-line
|
||||
Qt::strong_ordering compare(T lhs, T rhs); // defined out-of-line
|
||||
~~~
|
||||
|
||||
QStrongOrdering result = compare(a, b);
|
||||
Qt::strong_ordering result = compare(a, b);
|
||||
if (result < 0) {
|
||||
// a is less than b
|
||||
}
|
||||
@ -137,69 +137,69 @@
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QStrongOrdering::operator QPartialOrdering() const
|
||||
\fn Qt::strong_ordering::operator Qt::partial_ordering() const
|
||||
|
||||
Converts this QStrongOrdering value to a QPartialOrdering object using the
|
||||
Converts this Qt::strong_ordering value to a Qt::partial_ordering object using the
|
||||
following rules:
|
||||
|
||||
\list
|
||||
\li \l Less converts to \l {QPartialOrdering::Less}.
|
||||
\li \l Equivalent converts to \l {QPartialOrdering::Equivalent}.
|
||||
\li \l Equal converts to \l {QPartialOrdering::Equivalent}.
|
||||
\li \l Greater converts to \l {QPartialOrdering::Greater}.
|
||||
\li \l less converts to \l {Qt::partial_ordering::less}.
|
||||
\li \l equivalent converts to \l {Qt::partial_ordering::equivalent}.
|
||||
\li \l equal converts to \l {Qt::partial_ordering::equivalent}.
|
||||
\li \l greater converts to \l {Qt::partial_ordering::greater}.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QStrongOrdering::operator QWeakOrdering() const
|
||||
\fn Qt::strong_ordering::operator Qt::weak_ordering() const
|
||||
|
||||
Converts this QStrongOrdering value to a QWeakOrdering object using the
|
||||
Converts this Qt::strong_ordering value to a Qt::weak_ordering object using the
|
||||
following rules:
|
||||
|
||||
\list
|
||||
\li \l Less converts to \l {QWeakOrdering::Less}.
|
||||
\li \l Equivalent converts to \l {QWeakOrdering::Equivalent}.
|
||||
\li \l Equal converts to \l {QWeakOrdering::Equivalent}.
|
||||
\li \l Greater converts to \l {QWeakOrdering::Greater}.
|
||||
\li \l less converts to \l {Qt::weak_ordering::less}.
|
||||
\li \l equivalent converts to \l {Qt::weak_ordering::equivalent}.
|
||||
\li \l equal converts to \l {Qt::weak_ordering::equivalent}.
|
||||
\li \l greater converts to \l {Qt::weak_ordering::greater}.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QStrongOrdering::QStrongOrdering(std::strong_ordering stdorder)
|
||||
\fn Qt::strong_ordering::strong_ordering(std::strong_ordering stdorder)
|
||||
|
||||
Constructs a QStrongOrdering object from \a stdorder using the following rules:
|
||||
Constructs a Qt::strong_ordering object from \a stdorder using the following rules:
|
||||
|
||||
\list
|
||||
\li std::strong_ordering::less converts to \l Less.
|
||||
\li std::strong_ordering::equivalent converts to \l Equivalent.
|
||||
\li std::strong_ordering::equal converts to \l Equal.
|
||||
\li std::strong_ordering::greater converts to \l Greater.
|
||||
\li std::strong_ordering::less converts to \l less.
|
||||
\li std::strong_ordering::equivalent converts to \l equivalent.
|
||||
\li std::strong_ordering::equal converts to \l equal.
|
||||
\li std::strong_ordering::greater converts to \l greater.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QStrongOrdering::operator std::strong_ordering() const
|
||||
\fn Qt::strong_ordering::operator std::strong_ordering() const
|
||||
|
||||
Converts this QStrongOrdering value to a std::strong_ordering object using
|
||||
Converts this Qt::strong_ordering value to a std::strong_ordering object using
|
||||
the following rules:
|
||||
|
||||
\list
|
||||
\li \l Less converts to std::strong_ordering::less.
|
||||
\li \l Equivalent converts to std::strong_ordering::equivalent.
|
||||
\li \l Equal converts to std::strong_ordering::equal.
|
||||
\li \l Greater converts to std::strong_ordering::greater.
|
||||
\li \l less converts to std::strong_ordering::less.
|
||||
\li \l equivalent converts to std::strong_ordering::equivalent.
|
||||
\li \l equal converts to std::strong_ordering::equal.
|
||||
\li \l greater converts to std::strong_ordering::greater.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn bool QStrongOrdering::operator==(QStrongOrdering lhs, QStrongOrdering rhs)
|
||||
\fn bool Qt::strong_ordering::operator==(Qt::strong_ordering lhs, Qt::strong_ordering rhs)
|
||||
|
||||
Returns true if \a lhs and \a rhs represent the same result;
|
||||
otherwise, returns false.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn bool QStrongOrdering::operator!=(QStrongOrdering lhs, QStrongOrdering rhs)
|
||||
\fn bool Qt::strong_ordering::operator!=(Qt::strong_ordering lhs, Qt::strong_ordering rhs)
|
||||
|
||||
Returns true if \a lhs and \a rhs represent different results;
|
||||
otherwise, returns true.
|
||||
@ -207,29 +207,29 @@
|
||||
|
||||
/*!
|
||||
\internal
|
||||
\relates QStrongOrdering
|
||||
\fn bool operator==(QStrongOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator!=(QStrongOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator< (QStrongOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator<=(QStrongOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator> (QStrongOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator>=(QStrongOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\relates Qt::strong_ordering
|
||||
\fn bool operator==(Qt::strong_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator!=(Qt::strong_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator< (Qt::strong_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator<=(Qt::strong_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator> (Qt::strong_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator>=(Qt::strong_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
|
||||
\fn bool operator==(QtPrivate::CompareAgainstLiteralZero, QStrongOrdering rhs)
|
||||
\fn bool operator!=(QtPrivate::CompareAgainstLiteralZero, QStrongOrdering rhs)
|
||||
\fn bool operator< (QtPrivate::CompareAgainstLiteralZero, QStrongOrdering rhs)
|
||||
\fn bool operator<=(QtPrivate::CompareAgainstLiteralZero, QStrongOrdering rhs)
|
||||
\fn bool operator> (QtPrivate::CompareAgainstLiteralZero, QStrongOrdering rhs)
|
||||
\fn bool operator>=(QtPrivate::CompareAgainstLiteralZero, QStrongOrdering rhs)
|
||||
\fn bool operator==(QtPrivate::CompareAgainstLiteralZero, Qt::strong_ordering rhs)
|
||||
\fn bool operator!=(QtPrivate::CompareAgainstLiteralZero, Qt::strong_ordering rhs)
|
||||
\fn bool operator< (QtPrivate::CompareAgainstLiteralZero, Qt::strong_ordering rhs)
|
||||
\fn bool operator<=(QtPrivate::CompareAgainstLiteralZero, Qt::strong_ordering rhs)
|
||||
\fn bool operator> (QtPrivate::CompareAgainstLiteralZero, Qt::strong_ordering rhs)
|
||||
\fn bool operator>=(QtPrivate::CompareAgainstLiteralZero, Qt::strong_ordering rhs)
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QStrongOrdering::is_eq (QStrongOrdering o)
|
||||
\fn QStrongOrdering::is_neq (QStrongOrdering o)
|
||||
\fn QStrongOrdering::is_lt (QStrongOrdering o)
|
||||
\fn QStrongOrdering::is_lteq(QStrongOrdering o)
|
||||
\fn QStrongOrdering::is_gt (QStrongOrdering o)
|
||||
\fn QStrongOrdering::is_gteq(QStrongOrdering o)
|
||||
\fn Qt::strong_ordering::is_eq (Qt::strong_ordering o)
|
||||
\fn Qt::strong_ordering::is_neq (Qt::strong_ordering o)
|
||||
\fn Qt::strong_ordering::is_lt (Qt::strong_ordering o)
|
||||
\fn Qt::strong_ordering::is_lteq(Qt::strong_ordering o)
|
||||
\fn Qt::strong_ordering::is_gt (Qt::strong_ordering o)
|
||||
\fn Qt::strong_ordering::is_gteq(Qt::strong_ordering o)
|
||||
|
||||
//! [is_eq_table]
|
||||
Converts \a o into the result of one of the six relational operators:
|
||||
@ -248,56 +248,56 @@
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable QStrongOrdering::Less
|
||||
\variable Qt::strong_ordering::less
|
||||
|
||||
Represents the result of a comparison where the left operand is less
|
||||
than the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable QStrongOrdering::Equivalent
|
||||
\variable Qt::strong_ordering::equivalent
|
||||
|
||||
Represents the result of a comparison where the left operand is equal
|
||||
to the right operand. Same as \l {QStrongOrdering::Equal}.
|
||||
to the right operand. Same as \l {Qt::strong_ordering::equal}.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable QStrongOrdering::Equal
|
||||
\variable Qt::strong_ordering::equal
|
||||
|
||||
Represents the result of a comparison where the left operand is equal
|
||||
to the right operand. Same as \l {QStrongOrdering::Equivalent}.
|
||||
to the right operand. Same as \l {Qt::strong_ordering::equivalent}.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable QStrongOrdering::Greater
|
||||
\variable Qt::strong_ordering::greater
|
||||
|
||||
Represents the result of a comparison where the left operand is greater
|
||||
than the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\class QWeakOrdering
|
||||
\class Qt::weak_ordering
|
||||
\inmodule QtCore
|
||||
\brief QWeakOrdering represents a comparison where equivalent values are
|
||||
\brief Qt::weak_ordering represents a comparison where equivalent values are
|
||||
still distinguishable.
|
||||
\sa QStrongOrdering, QPartialOrdering, {Comparison types overview}
|
||||
\sa Qt::strong_ordering, Qt::partial_ordering, {Comparison types overview}
|
||||
\since 6.7
|
||||
|
||||
A value of type QWeakOrdering is typically returned from a three-way
|
||||
A value of type Qt::weak_ordering is typically returned from a three-way
|
||||
comparison function. Such a function compares two objects and establishes
|
||||
the order of the elements relative to each other.
|
||||
|
||||
The possible values of type QWeakOrdering are fully represented by the
|
||||
The possible values of type Qt::weak_ordering are fully represented by the
|
||||
following three symbolic constants:
|
||||
|
||||
\list
|
||||
\li \c Less represents that the left operand is less than the right;
|
||||
\li \c Equivalent represents that the left operand is equivalent to the
|
||||
\li \l less represents that the left operand is less than the right;
|
||||
\li \l equivalent represents that the left operand is equivalent to the
|
||||
right;
|
||||
\li \c Greater represents that the left operand is greater than the right,
|
||||
\li \l greater represents that the left operand is greater than the right,
|
||||
\endlist
|
||||
|
||||
QWeakOrdering is idiomatically used by comparing an instance against a
|
||||
Qt::weak_ordering is idiomatically used by comparing an instance against a
|
||||
literal zero, for instance like this:
|
||||
|
||||
\code
|
||||
@ -305,10 +305,10 @@
|
||||
// given a, b, c, d as objects of some type that allows for a 3-way compare,
|
||||
// and a compare function declared as follows:
|
||||
|
||||
QWeakOrdering compare(T lhs, T rhs); // defined out-of-line
|
||||
Qt::weak_ordering compare(T lhs, T rhs); // defined out-of-line
|
||||
~~~
|
||||
|
||||
QWeakOrdering result = compare(a, b);
|
||||
Qt::weak_ordering result = compare(a, b);
|
||||
if (result < 0) {
|
||||
// a is less than b
|
||||
}
|
||||
@ -321,52 +321,52 @@
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QWeakOrdering::operator QPartialOrdering() const
|
||||
\fn Qt::weak_ordering::operator Qt::partial_ordering() const
|
||||
|
||||
Converts this QWeakOrdering value to a QPartialOrdering object using the
|
||||
Converts this Qt::weak_ordering value to a Qt::partial_ordering object using the
|
||||
following rules:
|
||||
|
||||
\list
|
||||
\li \l Less converts to \l {QPartialOrdering::Less}.
|
||||
\li \l Equivalent converts to \l {QPartialOrdering::Equivalent}.
|
||||
\li \l Greater converts to \l {QPartialOrdering::Greater}.
|
||||
\li \l less converts to \l {Qt::partial_ordering::less}.
|
||||
\li \l equivalent converts to \l {Qt::partial_ordering::equivalent}.
|
||||
\li \l greater converts to \l {Qt::partial_ordering::greater}.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QWeakOrdering::QWeakOrdering(std::weak_ordering stdorder)
|
||||
\fn Qt::weak_ordering::weak_ordering(std::weak_ordering stdorder)
|
||||
|
||||
Constructs a QWeakOrdering object from \a stdorder using the following rules:
|
||||
Constructs a Qt::weak_ordering object from \a stdorder using the following rules:
|
||||
|
||||
\list
|
||||
\li std::weak_ordering::less converts to \l Less.
|
||||
\li std::weak_ordering::equivalent converts to \l Equivalent.
|
||||
\li std::weak_ordering::greater converts to \l Greater.
|
||||
\li std::weak_ordering::less converts to \l less.
|
||||
\li std::weak_ordering::equivalent converts to \l equivalent.
|
||||
\li std::weak_ordering::greater converts to \l greater.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QWeakOrdering::operator std::weak_ordering() const
|
||||
\fn Qt::weak_ordering::operator std::weak_ordering() const
|
||||
|
||||
Converts this QWeakOrdering value to a std::weak_ordering object using
|
||||
Converts this Qt::weak_ordering value to a std::weak_ordering object using
|
||||
the following rules:
|
||||
|
||||
\list
|
||||
\li \l Less converts to std::weak_ordering::less.
|
||||
\li \l Equivalent converts to std::weak_ordering::equivalent.
|
||||
\li \l Greater converts to std::weak_ordering::greater.
|
||||
\li \l less converts to std::weak_ordering::less.
|
||||
\li \l equivalent converts to std::weak_ordering::equivalent.
|
||||
\li \l greater converts to std::weak_ordering::greater.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn bool QWeakOrdering::operator==(QWeakOrdering lhs, QWeakOrdering rhs)
|
||||
\fn bool Qt::weak_ordering::operator==(Qt::weak_ordering lhs, Qt::weak_ordering rhs)
|
||||
|
||||
Return true if \a lhs and \a rhs represent the same result;
|
||||
otherwise, returns false.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn bool QWeakOrdering::operator!=(QWeakOrdering lhs, QWeakOrdering rhs)
|
||||
\fn bool Qt::weak_ordering::operator!=(Qt::weak_ordering lhs, Qt::weak_ordering rhs)
|
||||
|
||||
Return true if \a lhs and \a rhs represent different results;
|
||||
otherwise, returns true.
|
||||
@ -374,29 +374,29 @@
|
||||
|
||||
/*!
|
||||
\internal
|
||||
\relates QWeakOrdering
|
||||
\fn bool operator==(QWeakOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator!=(QWeakOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator< (QWeakOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator<=(QWeakOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator> (QWeakOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator>=(QWeakOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\relates Qt::weak_ordering
|
||||
\fn bool operator==(Qt::weak_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator!=(Qt::weak_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator< (Qt::weak_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator<=(Qt::weak_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator> (Qt::weak_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator>=(Qt::weak_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
|
||||
\fn bool operator==(QtPrivate::CompareAgainstLiteralZero, QWeakOrdering rhs)
|
||||
\fn bool operator!=(QtPrivate::CompareAgainstLiteralZero, QWeakOrdering rhs)
|
||||
\fn bool operator< (QtPrivate::CompareAgainstLiteralZero, QWeakOrdering rhs)
|
||||
\fn bool operator<=(QtPrivate::CompareAgainstLiteralZero, QWeakOrdering rhs)
|
||||
\fn bool operator> (QtPrivate::CompareAgainstLiteralZero, QWeakOrdering rhs)
|
||||
\fn bool operator>=(QtPrivate::CompareAgainstLiteralZero, QWeakOrdering rhs)
|
||||
\fn bool operator==(QtPrivate::CompareAgainstLiteralZero, Qt::weak_ordering rhs)
|
||||
\fn bool operator!=(QtPrivate::CompareAgainstLiteralZero, Qt::weak_ordering rhs)
|
||||
\fn bool operator< (QtPrivate::CompareAgainstLiteralZero, Qt::weak_ordering rhs)
|
||||
\fn bool operator<=(QtPrivate::CompareAgainstLiteralZero, Qt::weak_ordering rhs)
|
||||
\fn bool operator> (QtPrivate::CompareAgainstLiteralZero, Qt::weak_ordering rhs)
|
||||
\fn bool operator>=(QtPrivate::CompareAgainstLiteralZero, Qt::weak_ordering rhs)
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn QWeakOrdering::is_eq (QWeakOrdering o)
|
||||
\fn QWeakOrdering::is_neq (QWeakOrdering o)
|
||||
\fn QWeakOrdering::is_lt (QWeakOrdering o)
|
||||
\fn QWeakOrdering::is_lteq(QWeakOrdering o)
|
||||
\fn QWeakOrdering::is_gt (QWeakOrdering o)
|
||||
\fn QWeakOrdering::is_gteq(QWeakOrdering o)
|
||||
\fn Qt::weak_ordering::is_eq (Qt::weak_ordering o)
|
||||
\fn Qt::weak_ordering::is_neq (Qt::weak_ordering o)
|
||||
\fn Qt::weak_ordering::is_lt (Qt::weak_ordering o)
|
||||
\fn Qt::weak_ordering::is_lteq(Qt::weak_ordering o)
|
||||
\fn Qt::weak_ordering::is_gt (Qt::weak_ordering o)
|
||||
\fn Qt::weak_ordering::is_gteq(Qt::weak_ordering o)
|
||||
|
||||
\include qcompare.qdoc is_eq_table
|
||||
|
||||
@ -404,32 +404,185 @@
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable QWeakOrdering::Less
|
||||
\variable Qt::weak_ordering::less
|
||||
|
||||
Represents the result of a comparison where the left operand is less than
|
||||
the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable QWeakOrdering::Equivalent
|
||||
\variable Qt::weak_ordering::equivalent
|
||||
|
||||
Represents the result of a comparison where the left operand is equivalent
|
||||
to the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable QWeakOrdering::Greater
|
||||
\variable Qt::weak_ordering::greater
|
||||
|
||||
Represents the result of a comparison where the left operand is greater
|
||||
than the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\class Qt::partial_ordering
|
||||
\inmodule QtCore
|
||||
\brief Qt::partial_ordering represents the result of a comparison that allows
|
||||
for unordered results.
|
||||
\sa Qt::strong_ordering, Qt::weak_ordering, {Comparison types overview}
|
||||
\since 6.7
|
||||
|
||||
A value of type Qt::partial_ordering is typically returned from a
|
||||
three-way comparison function. Such a function compares two
|
||||
objects, and it may either establish that the two objects are
|
||||
ordered relative to each other, or that they are not ordered. The
|
||||
Qt::partial_ordering value returned from the comparison function
|
||||
represents one of those possibilities.
|
||||
|
||||
The possible values of type Qt::partial_ordering are, in fact, fully
|
||||
represented by the following four symbolic constants:
|
||||
|
||||
\list
|
||||
\li \l less represents that the left operand is less than the right;
|
||||
\li \l equivalent represents that left operand is equivalent to the right;
|
||||
\li \l greater represents that the left operand is greater than the right;
|
||||
\li \l unordered represents that the left operand is \e {not ordered} with
|
||||
respect to the right operand.
|
||||
\endlist
|
||||
|
||||
Qt::partial_ordering is idiomatically used by comparing an instance
|
||||
against a literal zero, for instance like this:
|
||||
|
||||
\code
|
||||
|
||||
// given a, b, c, d as objects of some type that allows for a 3-way compare,
|
||||
// and a compare function declared as follows:
|
||||
|
||||
Qt::partial_ordering compare(T lhs, T rhs); // defined out-of-line
|
||||
~~~
|
||||
|
||||
Qt::partial_ordering result = compare(a, b);
|
||||
if (result < 0) {
|
||||
// a is less than b
|
||||
}
|
||||
|
||||
if (compare(c, d) >= 0) {
|
||||
// c is greater than or equal to d
|
||||
}
|
||||
|
||||
\endcode
|
||||
|
||||
A Qt::partial_ordering value which represents an unordered result will
|
||||
always return false when compared against literal 0.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn Qt::partial_ordering::partial_ordering(std::partial_ordering stdorder)
|
||||
|
||||
Constructs a Qt::partial_ordering object from \a stdorder using the following
|
||||
rules:
|
||||
|
||||
\list
|
||||
\li std::partial_ordering::less converts to \l less.
|
||||
\li std::partial_ordering::equivalent converts to \l equivalent.
|
||||
\li std::partial_ordering::greater converts to \l greater.
|
||||
\li std::partial_ordering::unordered converts to \l unordered
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn Qt::partial_ordering::operator std::partial_ordering() const
|
||||
|
||||
Converts this Qt::partial_ordering value to a std::partial_ordering object using
|
||||
the following rules:
|
||||
|
||||
\list
|
||||
\li \l less converts to std::partial_ordering::less.
|
||||
\li \l equivalent converts to std::partial_ordering::equivalent.
|
||||
\li \l greater converts to std::partial_ordering::greater.
|
||||
\li \l unordered converts to std::partial_ordering::unordered.
|
||||
\endlist
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn bool Qt::partial_ordering::operator==(Qt::partial_ordering lhs, Qt::partial_ordering rhs)
|
||||
|
||||
Return true if \a lhs and \a rhs represent the same result;
|
||||
otherwise, returns false.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn bool Qt::partial_ordering::operator!=(Qt::partial_ordering lhs, Qt::partial_ordering rhs)
|
||||
|
||||
Return true if \a lhs and \a rhs represent different results;
|
||||
otherwise, returns true.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\internal
|
||||
\relates Qt::partial_ordering
|
||||
\fn bool operator==(Qt::partial_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator!=(Qt::partial_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator< (Qt::partial_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator<=(Qt::partial_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator> (Qt::partial_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
\fn bool operator>=(Qt::partial_ordering lhs, QtPrivate::CompareAgainstLiteralZero)
|
||||
|
||||
\fn bool operator==(QtPrivate::CompareAgainstLiteralZero, Qt::partial_ordering rhs)
|
||||
\fn bool operator!=(QtPrivate::CompareAgainstLiteralZero, Qt::partial_ordering rhs)
|
||||
\fn bool operator< (QtPrivate::CompareAgainstLiteralZero, Qt::partial_ordering rhs)
|
||||
\fn bool operator<=(QtPrivate::CompareAgainstLiteralZero, Qt::partial_ordering rhs)
|
||||
\fn bool operator> (QtPrivate::CompareAgainstLiteralZero, Qt::partial_ordering rhs)
|
||||
\fn bool operator>=(QtPrivate::CompareAgainstLiteralZero, Qt::partial_ordering rhs)
|
||||
*/
|
||||
|
||||
/*!
|
||||
\fn Qt::partial_ordering::is_eq (Qt::partial_ordering o)
|
||||
\fn Qt::partial_ordering::is_neq (Qt::partial_ordering o)
|
||||
\fn Qt::partial_ordering::is_lt (Qt::partial_ordering o)
|
||||
\fn Qt::partial_ordering::is_lteq(Qt::partial_ordering o)
|
||||
\fn Qt::partial_ordering::is_gt (Qt::partial_ordering o)
|
||||
\fn Qt::partial_ordering::is_gteq(Qt::partial_ordering o)
|
||||
|
||||
\include qcompare.qdoc is_eq_table
|
||||
|
||||
These functions are provided for compatibility with \c{std::partial_ordering}.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable Qt::partial_ordering::less
|
||||
|
||||
Represents the result of a comparison where the left operand is less than
|
||||
the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable Qt::partial_ordering::equivalent
|
||||
|
||||
Represents the result of a comparison where the left operand is equivalent
|
||||
to the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable Qt::partial_ordering::greater
|
||||
|
||||
Represents the result of a comparison where the left operand is greater
|
||||
than the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\variable Qt::partial_ordering::unordered
|
||||
|
||||
Represents the result of a comparison where the left operand is not ordered
|
||||
with respect to the right operand.
|
||||
*/
|
||||
|
||||
/*!
|
||||
\class QPartialOrdering
|
||||
\inmodule QtCore
|
||||
\brief QPartialOrdering represents the result of a comparison that allows
|
||||
for unordered results.
|
||||
\sa QStrongOrdering, QWeakOrdering, {Comparison types overview}
|
||||
\sa Qt::strong_ordering, Qt::weak_ordering, {Comparison types overview}
|
||||
\since 6.0
|
||||
|
||||
A value of type QPartialOrdering is typically returned from a
|
||||
|
||||
@ -166,8 +166,8 @@ void testEqualityOperators(LeftType lhs, RightType rhs, bool expectedEqual)
|
||||
(==, !=, <, >, <=, >=) for the \a lhs operand of type \c {LeftType} and
|
||||
the \a rhs operand of type \c {RightType}.
|
||||
|
||||
The \c OrderingType must be one of QPartialOrdering, QStrongOrdering, or
|
||||
QWeakOrdering.
|
||||
The \c OrderingType must be one of Qt::partial_ordering,
|
||||
Qt::weak_ordering, or Qt::strong_ordering.
|
||||
|
||||
The \a expectedOrdering parameter provides the expected
|
||||
relation between \a lhs and \a rhs.
|
||||
@ -178,7 +178,7 @@ void testEqualityOperators(LeftType lhs, RightType rhs, bool expectedEqual)
|
||||
\code
|
||||
QDateTime now = QDateTime::currentDateTime();
|
||||
QDateTime later = now.addMSec(1);
|
||||
QTestPrivate::testComparisonOperators(now, later, QWeakOrdering::Less);
|
||||
QTestPrivate::testComparisonOperators(now, later, Qt::weak_ordering::less);
|
||||
if (QTest:currentTestFailed())
|
||||
return;
|
||||
\endcode
|
||||
@ -186,19 +186,18 @@ void testEqualityOperators(LeftType lhs, RightType rhs, bool expectedEqual)
|
||||
template <typename LeftType, typename RightType, typename OrderingType>
|
||||
void testAllComparisonOperators(LeftType lhs, RightType rhs, OrderingType expectedOrdering)
|
||||
{
|
||||
constexpr bool isQOrderingType = std::is_same_v<OrderingType, QPartialOrdering>
|
||||
|| std::is_same_v<OrderingType, QWeakOrdering>
|
||||
|| std::is_same_v<OrderingType, QStrongOrdering>;
|
||||
|
||||
constexpr bool isQOrderingType = std::is_same_v<OrderingType, Qt::partial_ordering>
|
||||
|| std::is_same_v<OrderingType, Qt::weak_ordering>
|
||||
|| std::is_same_v<OrderingType, Qt::strong_ordering>;
|
||||
static_assert(isQOrderingType,
|
||||
"Please provide, as the expectedOrdering parameter, a value "
|
||||
"of one of the Q{Partial,Weak,Strong}Ordering types.");
|
||||
"of one of the Qt::{partial,weak,strong_ordering types.");
|
||||
|
||||
// We have all sorts of operator==() between Q*Ordering and std::*_ordering
|
||||
// types, so we can just compare to QPartialOrdering.
|
||||
const bool expectedEqual = expectedOrdering == QPartialOrdering::Equivalent;
|
||||
const bool expectedLess = expectedOrdering == QPartialOrdering::Less;
|
||||
const bool expectedUnordered = expectedOrdering == QPartialOrdering::Unordered;
|
||||
// types, so we can just compare to Qt::partial_ordering.
|
||||
const bool expectedEqual = expectedOrdering == Qt::partial_ordering::equivalent;
|
||||
const bool expectedLess = expectedOrdering == Qt::partial_ordering::less;
|
||||
const bool expectedUnordered = expectedOrdering == Qt::partial_ordering::unordered;
|
||||
|
||||
CHECK_RUNTIME_CREF(CHECK_RUNTIME_LR, lhs, rhs, ==,
|
||||
!expectedUnordered && expectedEqual)
|
||||
|
||||
@ -12,6 +12,7 @@ class tst_QCompare: public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
private slots:
|
||||
void legacyPartialOrdering();
|
||||
void partialOrdering();
|
||||
void weakOrdering();
|
||||
void strongOrdering();
|
||||
@ -19,7 +20,7 @@ private slots:
|
||||
void is_eq_overloads();
|
||||
};
|
||||
|
||||
void tst_QCompare::partialOrdering()
|
||||
void tst_QCompare::legacyPartialOrdering()
|
||||
{
|
||||
static_assert(QPartialOrdering::Unordered == QPartialOrdering::Unordered);
|
||||
static_assert(QPartialOrdering::Unordered != QPartialOrdering::Less);
|
||||
@ -129,320 +130,430 @@ void tst_QCompare::partialOrdering()
|
||||
static_assert(!(0 >= QPartialOrdering::Greater));
|
||||
}
|
||||
|
||||
void tst_QCompare::partialOrdering()
|
||||
{
|
||||
static_assert(Qt::partial_ordering::unordered == Qt::partial_ordering::unordered);
|
||||
static_assert(Qt::partial_ordering::unordered != Qt::partial_ordering::less);
|
||||
static_assert(Qt::partial_ordering::unordered != Qt::partial_ordering::equivalent);
|
||||
static_assert(Qt::partial_ordering::unordered != Qt::partial_ordering::greater);
|
||||
|
||||
static_assert(Qt::partial_ordering::less != Qt::partial_ordering::unordered);
|
||||
static_assert(Qt::partial_ordering::less == Qt::partial_ordering::less);
|
||||
static_assert(Qt::partial_ordering::less != Qt::partial_ordering::equivalent);
|
||||
static_assert(Qt::partial_ordering::less != Qt::partial_ordering::greater);
|
||||
|
||||
static_assert(Qt::partial_ordering::equivalent != Qt::partial_ordering::unordered);
|
||||
static_assert(Qt::partial_ordering::equivalent != Qt::partial_ordering::less);
|
||||
static_assert(Qt::partial_ordering::equivalent == Qt::partial_ordering::equivalent);
|
||||
static_assert(Qt::partial_ordering::equivalent != Qt::partial_ordering::greater);
|
||||
|
||||
static_assert(Qt::partial_ordering::greater != Qt::partial_ordering::unordered);
|
||||
static_assert(Qt::partial_ordering::greater != Qt::partial_ordering::less);
|
||||
static_assert(Qt::partial_ordering::greater != Qt::partial_ordering::equivalent);
|
||||
static_assert(Qt::partial_ordering::greater == Qt::partial_ordering::greater);
|
||||
|
||||
static_assert(!is_eq (Qt::partial_ordering::unordered));
|
||||
static_assert(!is_neq (Qt::partial_ordering::unordered));
|
||||
static_assert(!is_lt (Qt::partial_ordering::unordered));
|
||||
static_assert(!is_lteq(Qt::partial_ordering::unordered));
|
||||
static_assert(!is_gt (Qt::partial_ordering::unordered));
|
||||
static_assert(!is_gteq(Qt::partial_ordering::unordered));
|
||||
|
||||
static_assert(!(Qt::partial_ordering::unordered == 0));
|
||||
static_assert(!(Qt::partial_ordering::unordered != 0));
|
||||
static_assert(!(Qt::partial_ordering::unordered < 0));
|
||||
static_assert(!(Qt::partial_ordering::unordered <= 0));
|
||||
static_assert(!(Qt::partial_ordering::unordered > 0));
|
||||
static_assert(!(Qt::partial_ordering::unordered >= 0));
|
||||
|
||||
static_assert(!(0 == Qt::partial_ordering::unordered));
|
||||
static_assert(!(0 != Qt::partial_ordering::unordered));
|
||||
static_assert(!(0 < Qt::partial_ordering::unordered));
|
||||
static_assert(!(0 <= Qt::partial_ordering::unordered));
|
||||
static_assert(!(0 > Qt::partial_ordering::unordered));
|
||||
static_assert(!(0 >= Qt::partial_ordering::unordered));
|
||||
|
||||
|
||||
static_assert(!is_eq (Qt::partial_ordering::less));
|
||||
static_assert( is_neq (Qt::partial_ordering::less));
|
||||
static_assert( is_lt (Qt::partial_ordering::less));
|
||||
static_assert( is_lteq(Qt::partial_ordering::less));
|
||||
static_assert(!is_gt (Qt::partial_ordering::less));
|
||||
static_assert(!is_gteq(Qt::partial_ordering::less));
|
||||
|
||||
static_assert(!(Qt::partial_ordering::less == 0));
|
||||
static_assert( (Qt::partial_ordering::less != 0));
|
||||
static_assert( (Qt::partial_ordering::less < 0));
|
||||
static_assert( (Qt::partial_ordering::less <= 0));
|
||||
static_assert(!(Qt::partial_ordering::less > 0));
|
||||
static_assert(!(Qt::partial_ordering::less >= 0));
|
||||
|
||||
static_assert(!(0 == Qt::partial_ordering::less));
|
||||
static_assert( (0 != Qt::partial_ordering::less));
|
||||
static_assert(!(0 < Qt::partial_ordering::less));
|
||||
static_assert(!(0 <= Qt::partial_ordering::less));
|
||||
static_assert( (0 > Qt::partial_ordering::less));
|
||||
static_assert( (0 >= Qt::partial_ordering::less));
|
||||
|
||||
|
||||
static_assert( is_eq (Qt::partial_ordering::equivalent));
|
||||
static_assert(!is_neq (Qt::partial_ordering::equivalent));
|
||||
static_assert(!is_lt (Qt::partial_ordering::equivalent));
|
||||
static_assert( is_lteq(Qt::partial_ordering::equivalent));
|
||||
static_assert(!is_gt (Qt::partial_ordering::equivalent));
|
||||
static_assert( is_gteq(Qt::partial_ordering::equivalent));
|
||||
|
||||
static_assert( (Qt::partial_ordering::equivalent == 0));
|
||||
static_assert(!(Qt::partial_ordering::equivalent != 0));
|
||||
static_assert(!(Qt::partial_ordering::equivalent < 0));
|
||||
static_assert( (Qt::partial_ordering::equivalent <= 0));
|
||||
static_assert(!(Qt::partial_ordering::equivalent > 0));
|
||||
static_assert( (Qt::partial_ordering::equivalent >= 0));
|
||||
|
||||
static_assert( (0 == Qt::partial_ordering::equivalent));
|
||||
static_assert(!(0 != Qt::partial_ordering::equivalent));
|
||||
static_assert(!(0 < Qt::partial_ordering::equivalent));
|
||||
static_assert( (0 <= Qt::partial_ordering::equivalent));
|
||||
static_assert(!(0 > Qt::partial_ordering::equivalent));
|
||||
static_assert( (0 >= Qt::partial_ordering::equivalent));
|
||||
|
||||
|
||||
static_assert(!is_eq (Qt::partial_ordering::greater));
|
||||
static_assert( is_neq (Qt::partial_ordering::greater));
|
||||
static_assert(!is_lt (Qt::partial_ordering::greater));
|
||||
static_assert(!is_lteq(Qt::partial_ordering::greater));
|
||||
static_assert( is_gt (Qt::partial_ordering::greater));
|
||||
static_assert( is_gteq(Qt::partial_ordering::greater));
|
||||
|
||||
static_assert(!(Qt::partial_ordering::greater == 0));
|
||||
static_assert( (Qt::partial_ordering::greater != 0));
|
||||
static_assert(!(Qt::partial_ordering::greater < 0));
|
||||
static_assert(!(Qt::partial_ordering::greater <= 0));
|
||||
static_assert( (Qt::partial_ordering::greater > 0));
|
||||
static_assert( (Qt::partial_ordering::greater >= 0));
|
||||
|
||||
static_assert(!(0 == Qt::partial_ordering::greater));
|
||||
static_assert( (0 != Qt::partial_ordering::greater));
|
||||
static_assert( (0 < Qt::partial_ordering::greater));
|
||||
static_assert( (0 <= Qt::partial_ordering::greater));
|
||||
static_assert(!(0 > Qt::partial_ordering::greater));
|
||||
static_assert(!(0 >= Qt::partial_ordering::greater));
|
||||
}
|
||||
|
||||
void tst_QCompare::weakOrdering()
|
||||
{
|
||||
static_assert(QWeakOrdering::Less == QWeakOrdering::Less);
|
||||
static_assert(QWeakOrdering::Less != QWeakOrdering::Equivalent);
|
||||
static_assert(QWeakOrdering::Less != QWeakOrdering::Greater);
|
||||
static_assert(Qt::weak_ordering::less == Qt::weak_ordering::less);
|
||||
static_assert(Qt::weak_ordering::less != Qt::weak_ordering::equivalent);
|
||||
static_assert(Qt::weak_ordering::less != Qt::weak_ordering::greater);
|
||||
|
||||
static_assert(QWeakOrdering::Equivalent != QWeakOrdering::Less);
|
||||
static_assert(QWeakOrdering::Equivalent == QWeakOrdering::Equivalent);
|
||||
static_assert(QWeakOrdering::Equivalent != QWeakOrdering::Greater);
|
||||
static_assert(Qt::weak_ordering::equivalent != Qt::weak_ordering::less);
|
||||
static_assert(Qt::weak_ordering::equivalent == Qt::weak_ordering::equivalent);
|
||||
static_assert(Qt::weak_ordering::equivalent != Qt::weak_ordering::greater);
|
||||
|
||||
static_assert(QWeakOrdering::Greater != QWeakOrdering::Less);
|
||||
static_assert(QWeakOrdering::Greater != QWeakOrdering::Equivalent);
|
||||
static_assert(QWeakOrdering::Greater == QWeakOrdering::Greater);
|
||||
static_assert(Qt::weak_ordering::greater != Qt::weak_ordering::less);
|
||||
static_assert(Qt::weak_ordering::greater != Qt::weak_ordering::equivalent);
|
||||
static_assert(Qt::weak_ordering::greater == Qt::weak_ordering::greater);
|
||||
|
||||
static_assert(!is_eq (QWeakOrdering::Less));
|
||||
static_assert( is_neq (QWeakOrdering::Less));
|
||||
static_assert( is_lt (QWeakOrdering::Less));
|
||||
static_assert( is_lteq(QWeakOrdering::Less));
|
||||
static_assert(!is_gt (QWeakOrdering::Less));
|
||||
static_assert(!is_gteq(QWeakOrdering::Less));
|
||||
static_assert(!is_eq (Qt::weak_ordering::less));
|
||||
static_assert( is_neq (Qt::weak_ordering::less));
|
||||
static_assert( is_lt (Qt::weak_ordering::less));
|
||||
static_assert( is_lteq(Qt::weak_ordering::less));
|
||||
static_assert(!is_gt (Qt::weak_ordering::less));
|
||||
static_assert(!is_gteq(Qt::weak_ordering::less));
|
||||
|
||||
static_assert(!(QWeakOrdering::Less == 0));
|
||||
static_assert( (QWeakOrdering::Less != 0));
|
||||
static_assert( (QWeakOrdering::Less < 0));
|
||||
static_assert( (QWeakOrdering::Less <= 0));
|
||||
static_assert(!(QWeakOrdering::Less > 0));
|
||||
static_assert(!(QWeakOrdering::Less >= 0));
|
||||
static_assert(!(Qt::weak_ordering::less == 0));
|
||||
static_assert( (Qt::weak_ordering::less != 0));
|
||||
static_assert( (Qt::weak_ordering::less < 0));
|
||||
static_assert( (Qt::weak_ordering::less <= 0));
|
||||
static_assert(!(Qt::weak_ordering::less > 0));
|
||||
static_assert(!(Qt::weak_ordering::less >= 0));
|
||||
|
||||
static_assert(!(0 == QWeakOrdering::Less));
|
||||
static_assert( (0 != QWeakOrdering::Less));
|
||||
static_assert(!(0 < QWeakOrdering::Less));
|
||||
static_assert(!(0 <= QWeakOrdering::Less));
|
||||
static_assert( (0 > QWeakOrdering::Less));
|
||||
static_assert( (0 >= QWeakOrdering::Less));
|
||||
static_assert(!(0 == Qt::weak_ordering::less));
|
||||
static_assert( (0 != Qt::weak_ordering::less));
|
||||
static_assert(!(0 < Qt::weak_ordering::less));
|
||||
static_assert(!(0 <= Qt::weak_ordering::less));
|
||||
static_assert( (0 > Qt::weak_ordering::less));
|
||||
static_assert( (0 >= Qt::weak_ordering::less));
|
||||
|
||||
|
||||
static_assert( is_eq (QWeakOrdering::Equivalent));
|
||||
static_assert(!is_neq (QWeakOrdering::Equivalent));
|
||||
static_assert(!is_lt (QWeakOrdering::Equivalent));
|
||||
static_assert( is_lteq(QWeakOrdering::Equivalent));
|
||||
static_assert(!is_gt (QWeakOrdering::Equivalent));
|
||||
static_assert( is_gteq(QWeakOrdering::Equivalent));
|
||||
static_assert( is_eq (Qt::weak_ordering::equivalent));
|
||||
static_assert(!is_neq (Qt::weak_ordering::equivalent));
|
||||
static_assert(!is_lt (Qt::weak_ordering::equivalent));
|
||||
static_assert( is_lteq(Qt::weak_ordering::equivalent));
|
||||
static_assert(!is_gt (Qt::weak_ordering::equivalent));
|
||||
static_assert( is_gteq(Qt::weak_ordering::equivalent));
|
||||
|
||||
static_assert( (QWeakOrdering::Equivalent == 0));
|
||||
static_assert(!(QWeakOrdering::Equivalent != 0));
|
||||
static_assert(!(QWeakOrdering::Equivalent < 0));
|
||||
static_assert( (QWeakOrdering::Equivalent <= 0));
|
||||
static_assert(!(QWeakOrdering::Equivalent > 0));
|
||||
static_assert( (QWeakOrdering::Equivalent >= 0));
|
||||
static_assert( (Qt::weak_ordering::equivalent == 0));
|
||||
static_assert(!(Qt::weak_ordering::equivalent != 0));
|
||||
static_assert(!(Qt::weak_ordering::equivalent < 0));
|
||||
static_assert( (Qt::weak_ordering::equivalent <= 0));
|
||||
static_assert(!(Qt::weak_ordering::equivalent > 0));
|
||||
static_assert( (Qt::weak_ordering::equivalent >= 0));
|
||||
|
||||
static_assert( (0 == QWeakOrdering::Equivalent));
|
||||
static_assert(!(0 != QWeakOrdering::Equivalent));
|
||||
static_assert(!(0 < QWeakOrdering::Equivalent));
|
||||
static_assert( (0 <= QWeakOrdering::Equivalent));
|
||||
static_assert(!(0 > QWeakOrdering::Equivalent));
|
||||
static_assert( (0 >= QWeakOrdering::Equivalent));
|
||||
static_assert( (0 == Qt::weak_ordering::equivalent));
|
||||
static_assert(!(0 != Qt::weak_ordering::equivalent));
|
||||
static_assert(!(0 < Qt::weak_ordering::equivalent));
|
||||
static_assert( (0 <= Qt::weak_ordering::equivalent));
|
||||
static_assert(!(0 > Qt::weak_ordering::equivalent));
|
||||
static_assert( (0 >= Qt::weak_ordering::equivalent));
|
||||
|
||||
|
||||
static_assert(!is_eq (QWeakOrdering::Greater));
|
||||
static_assert( is_neq (QWeakOrdering::Greater));
|
||||
static_assert(!is_lt (QWeakOrdering::Greater));
|
||||
static_assert(!is_lteq(QWeakOrdering::Greater));
|
||||
static_assert( is_gt (QWeakOrdering::Greater));
|
||||
static_assert( is_gteq(QWeakOrdering::Greater));
|
||||
static_assert(!is_eq (Qt::weak_ordering::greater));
|
||||
static_assert( is_neq (Qt::weak_ordering::greater));
|
||||
static_assert(!is_lt (Qt::weak_ordering::greater));
|
||||
static_assert(!is_lteq(Qt::weak_ordering::greater));
|
||||
static_assert( is_gt (Qt::weak_ordering::greater));
|
||||
static_assert( is_gteq(Qt::weak_ordering::greater));
|
||||
|
||||
static_assert(!(QWeakOrdering::Greater == 0));
|
||||
static_assert( (QWeakOrdering::Greater != 0));
|
||||
static_assert(!(QWeakOrdering::Greater < 0));
|
||||
static_assert(!(QWeakOrdering::Greater <= 0));
|
||||
static_assert( (QWeakOrdering::Greater > 0));
|
||||
static_assert( (QWeakOrdering::Greater >= 0));
|
||||
static_assert(!(Qt::weak_ordering::greater == 0));
|
||||
static_assert( (Qt::weak_ordering::greater != 0));
|
||||
static_assert(!(Qt::weak_ordering::greater < 0));
|
||||
static_assert(!(Qt::weak_ordering::greater <= 0));
|
||||
static_assert( (Qt::weak_ordering::greater > 0));
|
||||
static_assert( (Qt::weak_ordering::greater >= 0));
|
||||
|
||||
static_assert(!(0 == QWeakOrdering::Greater));
|
||||
static_assert( (0 != QWeakOrdering::Greater));
|
||||
static_assert( (0 < QWeakOrdering::Greater));
|
||||
static_assert( (0 <= QWeakOrdering::Greater));
|
||||
static_assert(!(0 > QWeakOrdering::Greater));
|
||||
static_assert(!(0 >= QWeakOrdering::Greater));
|
||||
static_assert(!(0 == Qt::weak_ordering::greater));
|
||||
static_assert( (0 != Qt::weak_ordering::greater));
|
||||
static_assert( (0 < Qt::weak_ordering::greater));
|
||||
static_assert( (0 <= Qt::weak_ordering::greater));
|
||||
static_assert(!(0 > Qt::weak_ordering::greater));
|
||||
static_assert(!(0 >= Qt::weak_ordering::greater));
|
||||
}
|
||||
|
||||
void tst_QCompare::strongOrdering()
|
||||
{
|
||||
static_assert(QStrongOrdering::Less == QStrongOrdering::Less);
|
||||
static_assert(QStrongOrdering::Less != QStrongOrdering::Equal);
|
||||
static_assert(QStrongOrdering::Less != QStrongOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Less != QStrongOrdering::Greater);
|
||||
static_assert(Qt::strong_ordering::less == Qt::strong_ordering::less);
|
||||
static_assert(Qt::strong_ordering::less != Qt::strong_ordering::equal);
|
||||
static_assert(Qt::strong_ordering::less != Qt::strong_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::less != Qt::strong_ordering::greater);
|
||||
|
||||
static_assert(QStrongOrdering::Equal != QStrongOrdering::Less);
|
||||
static_assert(QStrongOrdering::Equal == QStrongOrdering::Equal);
|
||||
static_assert(QStrongOrdering::Equal == QStrongOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Equal != QStrongOrdering::Greater);
|
||||
static_assert(Qt::strong_ordering::equal != Qt::strong_ordering::less);
|
||||
static_assert(Qt::strong_ordering::equal == Qt::strong_ordering::equal);
|
||||
static_assert(Qt::strong_ordering::equal == Qt::strong_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::equal != Qt::strong_ordering::greater);
|
||||
|
||||
static_assert(QStrongOrdering::Equivalent != QStrongOrdering::Less);
|
||||
static_assert(QStrongOrdering::Equivalent == QStrongOrdering::Equal);
|
||||
static_assert(QStrongOrdering::Equivalent == QStrongOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Equivalent != QStrongOrdering::Greater);
|
||||
static_assert(Qt::strong_ordering::equivalent != Qt::strong_ordering::less);
|
||||
static_assert(Qt::strong_ordering::equivalent == Qt::strong_ordering::equal);
|
||||
static_assert(Qt::strong_ordering::equivalent == Qt::strong_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::equivalent != Qt::strong_ordering::greater);
|
||||
|
||||
static_assert(QStrongOrdering::Greater != QStrongOrdering::Less);
|
||||
static_assert(QStrongOrdering::Greater != QStrongOrdering::Equal);
|
||||
static_assert(QStrongOrdering::Greater != QStrongOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Greater == QStrongOrdering::Greater);
|
||||
static_assert(Qt::strong_ordering::greater != Qt::strong_ordering::less);
|
||||
static_assert(Qt::strong_ordering::greater != Qt::strong_ordering::equal);
|
||||
static_assert(Qt::strong_ordering::greater != Qt::strong_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::greater == Qt::strong_ordering::greater);
|
||||
|
||||
static_assert(!is_eq (QStrongOrdering::Less));
|
||||
static_assert( is_neq (QStrongOrdering::Less));
|
||||
static_assert( is_lt (QStrongOrdering::Less));
|
||||
static_assert( is_lteq(QStrongOrdering::Less));
|
||||
static_assert(!is_gt (QStrongOrdering::Less));
|
||||
static_assert(!is_gteq(QStrongOrdering::Less));
|
||||
static_assert(!is_eq (Qt::strong_ordering::less));
|
||||
static_assert( is_neq (Qt::strong_ordering::less));
|
||||
static_assert( is_lt (Qt::strong_ordering::less));
|
||||
static_assert( is_lteq(Qt::strong_ordering::less));
|
||||
static_assert(!is_gt (Qt::strong_ordering::less));
|
||||
static_assert(!is_gteq(Qt::strong_ordering::less));
|
||||
|
||||
static_assert(!(QStrongOrdering::Less == 0));
|
||||
static_assert( (QStrongOrdering::Less != 0));
|
||||
static_assert( (QStrongOrdering::Less < 0));
|
||||
static_assert( (QStrongOrdering::Less <= 0));
|
||||
static_assert(!(QStrongOrdering::Less > 0));
|
||||
static_assert(!(QStrongOrdering::Less >= 0));
|
||||
static_assert(!(Qt::strong_ordering::less == 0));
|
||||
static_assert( (Qt::strong_ordering::less != 0));
|
||||
static_assert( (Qt::strong_ordering::less < 0));
|
||||
static_assert( (Qt::strong_ordering::less <= 0));
|
||||
static_assert(!(Qt::strong_ordering::less > 0));
|
||||
static_assert(!(Qt::strong_ordering::less >= 0));
|
||||
|
||||
static_assert(!(0 == QStrongOrdering::Less));
|
||||
static_assert( (0 != QStrongOrdering::Less));
|
||||
static_assert(!(0 < QStrongOrdering::Less));
|
||||
static_assert(!(0 <= QStrongOrdering::Less));
|
||||
static_assert( (0 > QStrongOrdering::Less));
|
||||
static_assert( (0 >= QStrongOrdering::Less));
|
||||
static_assert(!(0 == Qt::strong_ordering::less));
|
||||
static_assert( (0 != Qt::strong_ordering::less));
|
||||
static_assert(!(0 < Qt::strong_ordering::less));
|
||||
static_assert(!(0 <= Qt::strong_ordering::less));
|
||||
static_assert( (0 > Qt::strong_ordering::less));
|
||||
static_assert( (0 >= Qt::strong_ordering::less));
|
||||
|
||||
|
||||
static_assert( is_eq (QStrongOrdering::Equal));
|
||||
static_assert(!is_neq (QStrongOrdering::Equal));
|
||||
static_assert(!is_lt (QStrongOrdering::Equal));
|
||||
static_assert( is_lteq(QStrongOrdering::Equal));
|
||||
static_assert(!is_gt (QStrongOrdering::Equal));
|
||||
static_assert( is_gteq(QStrongOrdering::Equal));
|
||||
static_assert( is_eq (Qt::strong_ordering::equal));
|
||||
static_assert(!is_neq (Qt::strong_ordering::equal));
|
||||
static_assert(!is_lt (Qt::strong_ordering::equal));
|
||||
static_assert( is_lteq(Qt::strong_ordering::equal));
|
||||
static_assert(!is_gt (Qt::strong_ordering::equal));
|
||||
static_assert( is_gteq(Qt::strong_ordering::equal));
|
||||
|
||||
static_assert( (QStrongOrdering::Equal == 0));
|
||||
static_assert(!(QStrongOrdering::Equal != 0));
|
||||
static_assert(!(QStrongOrdering::Equal < 0));
|
||||
static_assert( (QStrongOrdering::Equal <= 0));
|
||||
static_assert(!(QStrongOrdering::Equal > 0));
|
||||
static_assert( (QStrongOrdering::Equal >= 0));
|
||||
static_assert( (Qt::strong_ordering::equal == 0));
|
||||
static_assert(!(Qt::strong_ordering::equal != 0));
|
||||
static_assert(!(Qt::strong_ordering::equal < 0));
|
||||
static_assert( (Qt::strong_ordering::equal <= 0));
|
||||
static_assert(!(Qt::strong_ordering::equal > 0));
|
||||
static_assert( (Qt::strong_ordering::equal >= 0));
|
||||
|
||||
static_assert( (0 == QStrongOrdering::Equal));
|
||||
static_assert(!(0 != QStrongOrdering::Equal));
|
||||
static_assert(!(0 < QStrongOrdering::Equal));
|
||||
static_assert( (0 <= QStrongOrdering::Equal));
|
||||
static_assert(!(0 > QStrongOrdering::Equal));
|
||||
static_assert( (0 >= QStrongOrdering::Equal));
|
||||
static_assert( (0 == Qt::strong_ordering::equal));
|
||||
static_assert(!(0 != Qt::strong_ordering::equal));
|
||||
static_assert(!(0 < Qt::strong_ordering::equal));
|
||||
static_assert( (0 <= Qt::strong_ordering::equal));
|
||||
static_assert(!(0 > Qt::strong_ordering::equal));
|
||||
static_assert( (0 >= Qt::strong_ordering::equal));
|
||||
|
||||
|
||||
static_assert( is_eq (QStrongOrdering::Equivalent));
|
||||
static_assert(!is_neq (QStrongOrdering::Equivalent));
|
||||
static_assert(!is_lt (QStrongOrdering::Equivalent));
|
||||
static_assert( is_lteq(QStrongOrdering::Equivalent));
|
||||
static_assert(!is_gt (QStrongOrdering::Equivalent));
|
||||
static_assert( is_gteq(QStrongOrdering::Equivalent));
|
||||
static_assert( is_eq (Qt::strong_ordering::equivalent));
|
||||
static_assert(!is_neq (Qt::strong_ordering::equivalent));
|
||||
static_assert(!is_lt (Qt::strong_ordering::equivalent));
|
||||
static_assert( is_lteq(Qt::strong_ordering::equivalent));
|
||||
static_assert(!is_gt (Qt::strong_ordering::equivalent));
|
||||
static_assert( is_gteq(Qt::strong_ordering::equivalent));
|
||||
|
||||
static_assert( (QStrongOrdering::Equivalent == 0));
|
||||
static_assert(!(QStrongOrdering::Equivalent != 0));
|
||||
static_assert(!(QStrongOrdering::Equivalent < 0));
|
||||
static_assert( (QStrongOrdering::Equivalent <= 0));
|
||||
static_assert(!(QStrongOrdering::Equivalent > 0));
|
||||
static_assert( (QStrongOrdering::Equivalent >= 0));
|
||||
static_assert( (Qt::strong_ordering::equivalent == 0));
|
||||
static_assert(!(Qt::strong_ordering::equivalent != 0));
|
||||
static_assert(!(Qt::strong_ordering::equivalent < 0));
|
||||
static_assert( (Qt::strong_ordering::equivalent <= 0));
|
||||
static_assert(!(Qt::strong_ordering::equivalent > 0));
|
||||
static_assert( (Qt::strong_ordering::equivalent >= 0));
|
||||
|
||||
static_assert( (0 == QStrongOrdering::Equivalent));
|
||||
static_assert(!(0 != QStrongOrdering::Equivalent));
|
||||
static_assert(!(0 < QStrongOrdering::Equivalent));
|
||||
static_assert( (0 <= QStrongOrdering::Equivalent));
|
||||
static_assert(!(0 > QStrongOrdering::Equivalent));
|
||||
static_assert( (0 >= QStrongOrdering::Equivalent));
|
||||
static_assert( (0 == Qt::strong_ordering::equivalent));
|
||||
static_assert(!(0 != Qt::strong_ordering::equivalent));
|
||||
static_assert(!(0 < Qt::strong_ordering::equivalent));
|
||||
static_assert( (0 <= Qt::strong_ordering::equivalent));
|
||||
static_assert(!(0 > Qt::strong_ordering::equivalent));
|
||||
static_assert( (0 >= Qt::strong_ordering::equivalent));
|
||||
|
||||
|
||||
static_assert(!is_eq (QStrongOrdering::Greater));
|
||||
static_assert( is_neq (QStrongOrdering::Greater));
|
||||
static_assert(!is_lt (QStrongOrdering::Greater));
|
||||
static_assert(!is_lteq(QStrongOrdering::Greater));
|
||||
static_assert( is_gt (QStrongOrdering::Greater));
|
||||
static_assert( is_gteq(QStrongOrdering::Greater));
|
||||
static_assert(!is_eq (Qt::strong_ordering::greater));
|
||||
static_assert( is_neq (Qt::strong_ordering::greater));
|
||||
static_assert(!is_lt (Qt::strong_ordering::greater));
|
||||
static_assert(!is_lteq(Qt::strong_ordering::greater));
|
||||
static_assert( is_gt (Qt::strong_ordering::greater));
|
||||
static_assert( is_gteq(Qt::strong_ordering::greater));
|
||||
|
||||
static_assert(!(QStrongOrdering::Greater == 0));
|
||||
static_assert( (QStrongOrdering::Greater != 0));
|
||||
static_assert(!(QStrongOrdering::Greater < 0));
|
||||
static_assert(!(QStrongOrdering::Greater <= 0));
|
||||
static_assert( (QStrongOrdering::Greater > 0));
|
||||
static_assert( (QStrongOrdering::Greater >= 0));
|
||||
static_assert(!(Qt::strong_ordering::greater == 0));
|
||||
static_assert( (Qt::strong_ordering::greater != 0));
|
||||
static_assert(!(Qt::strong_ordering::greater < 0));
|
||||
static_assert(!(Qt::strong_ordering::greater <= 0));
|
||||
static_assert( (Qt::strong_ordering::greater > 0));
|
||||
static_assert( (Qt::strong_ordering::greater >= 0));
|
||||
|
||||
static_assert(!(0 == QStrongOrdering::Greater));
|
||||
static_assert( (0 != QStrongOrdering::Greater));
|
||||
static_assert( (0 < QStrongOrdering::Greater));
|
||||
static_assert( (0 <= QStrongOrdering::Greater));
|
||||
static_assert(!(0 > QStrongOrdering::Greater));
|
||||
static_assert(!(0 >= QStrongOrdering::Greater));
|
||||
static_assert(!(0 == Qt::strong_ordering::greater));
|
||||
static_assert( (0 != Qt::strong_ordering::greater));
|
||||
static_assert( (0 < Qt::strong_ordering::greater));
|
||||
static_assert( (0 <= Qt::strong_ordering::greater));
|
||||
static_assert(!(0 > Qt::strong_ordering::greater));
|
||||
static_assert(!(0 >= Qt::strong_ordering::greater));
|
||||
}
|
||||
|
||||
void tst_QCompare::conversions()
|
||||
{
|
||||
// QWeakOrdering -> QPartialOrdering
|
||||
// Qt::weak_ordering -> Qt::partial_ordering
|
||||
{
|
||||
constexpr QPartialOrdering less = QWeakOrdering::Less;
|
||||
static_assert(less == QPartialOrdering::Less);
|
||||
constexpr QPartialOrdering equivalent = QWeakOrdering::Equivalent;
|
||||
static_assert(equivalent == QPartialOrdering::Equivalent);
|
||||
constexpr QPartialOrdering greater = QWeakOrdering::Greater;
|
||||
static_assert(greater == QPartialOrdering::Greater);
|
||||
constexpr Qt::partial_ordering less = Qt::weak_ordering::less;
|
||||
static_assert(less == Qt::partial_ordering::less);
|
||||
constexpr Qt::partial_ordering equivalent = Qt::weak_ordering::equivalent;
|
||||
static_assert(equivalent == Qt::partial_ordering::equivalent);
|
||||
constexpr Qt::partial_ordering greater = Qt::weak_ordering::greater;
|
||||
static_assert(greater == Qt::partial_ordering::greater);
|
||||
}
|
||||
// QStrongOrdering -> QPartialOrdering
|
||||
// Qt::strong_ordering -> Qt::partial_ordering
|
||||
{
|
||||
constexpr QPartialOrdering less = QStrongOrdering::Less;
|
||||
static_assert(less == QPartialOrdering::Less);
|
||||
constexpr QPartialOrdering equal = QStrongOrdering::Equal;
|
||||
static_assert(equal == QPartialOrdering::Equivalent);
|
||||
constexpr QPartialOrdering equivalent = QStrongOrdering::Equivalent;
|
||||
static_assert(equivalent == QPartialOrdering::Equivalent);
|
||||
constexpr QPartialOrdering greater = QStrongOrdering::Greater;
|
||||
static_assert(greater == QPartialOrdering::Greater);
|
||||
constexpr Qt::partial_ordering less = Qt::strong_ordering::less;
|
||||
static_assert(less == Qt::partial_ordering::less);
|
||||
constexpr Qt::partial_ordering equal = Qt::strong_ordering::equal;
|
||||
static_assert(equal == Qt::partial_ordering::equivalent);
|
||||
constexpr Qt::partial_ordering equivalent = Qt::strong_ordering::equivalent;
|
||||
static_assert(equivalent == Qt::partial_ordering::equivalent);
|
||||
constexpr Qt::partial_ordering greater = Qt::strong_ordering::greater;
|
||||
static_assert(greater == Qt::partial_ordering::greater);
|
||||
}
|
||||
// QStrongOrdering -> QWeakOrdering
|
||||
// Qt::strong_ordering -> Qt::weak_ordering
|
||||
{
|
||||
constexpr QWeakOrdering less = QStrongOrdering::Less;
|
||||
static_assert(less == QWeakOrdering::Less);
|
||||
constexpr QWeakOrdering equal = QStrongOrdering::Equal;
|
||||
static_assert(equal == QWeakOrdering::Equivalent);
|
||||
constexpr QWeakOrdering equivalent = QStrongOrdering::Equivalent;
|
||||
static_assert(equivalent == QWeakOrdering::Equivalent);
|
||||
constexpr QWeakOrdering greater = QStrongOrdering::Greater;
|
||||
static_assert(greater == QWeakOrdering::Greater);
|
||||
constexpr Qt::weak_ordering less = Qt::strong_ordering::less;
|
||||
static_assert(less == Qt::weak_ordering::less);
|
||||
constexpr Qt::weak_ordering equal = Qt::strong_ordering::equal;
|
||||
static_assert(equal == Qt::weak_ordering::equivalent);
|
||||
constexpr Qt::weak_ordering equivalent = Qt::strong_ordering::equivalent;
|
||||
static_assert(equivalent == Qt::weak_ordering::equivalent);
|
||||
constexpr Qt::weak_ordering greater = Qt::strong_ordering::greater;
|
||||
static_assert(greater == Qt::weak_ordering::greater);
|
||||
}
|
||||
// Mixed types
|
||||
{
|
||||
static_assert(QPartialOrdering::Less == QStrongOrdering::Less);
|
||||
static_assert(QPartialOrdering::Equivalent != QStrongOrdering::Less);
|
||||
static_assert(QPartialOrdering::Equivalent == QStrongOrdering::Equal);
|
||||
static_assert(QPartialOrdering::Greater == QStrongOrdering::Greater);
|
||||
static_assert(Qt::partial_ordering::less == Qt::strong_ordering::less);
|
||||
static_assert(Qt::partial_ordering::equivalent != Qt::strong_ordering::less);
|
||||
static_assert(Qt::partial_ordering::equivalent == Qt::strong_ordering::equal);
|
||||
static_assert(Qt::partial_ordering::greater == Qt::strong_ordering::greater);
|
||||
|
||||
static_assert(QPartialOrdering::Less == QWeakOrdering::Less);
|
||||
static_assert(QPartialOrdering::Equivalent == QWeakOrdering::Equivalent);
|
||||
static_assert(QPartialOrdering::Greater == QWeakOrdering::Greater);
|
||||
static_assert(Qt::partial_ordering::less == Qt::weak_ordering::less);
|
||||
static_assert(Qt::partial_ordering::equivalent == Qt::weak_ordering::equivalent);
|
||||
static_assert(Qt::partial_ordering::greater == Qt::weak_ordering::greater);
|
||||
|
||||
static_assert(QWeakOrdering::Less == QStrongOrdering::Less);
|
||||
static_assert(QWeakOrdering::Equivalent != QStrongOrdering::Greater);
|
||||
static_assert(QWeakOrdering::Equivalent == QStrongOrdering::Equal);
|
||||
static_assert(QWeakOrdering::Greater == QStrongOrdering::Greater);
|
||||
static_assert(Qt::weak_ordering::less == Qt::strong_ordering::less);
|
||||
static_assert(Qt::weak_ordering::equivalent != Qt::strong_ordering::greater);
|
||||
static_assert(Qt::weak_ordering::equivalent == Qt::strong_ordering::equal);
|
||||
static_assert(Qt::weak_ordering::greater == Qt::strong_ordering::greater);
|
||||
|
||||
static_assert(QWeakOrdering::Less == QPartialOrdering::Less);
|
||||
static_assert(QWeakOrdering::Equivalent == QPartialOrdering::Equivalent);
|
||||
static_assert(QWeakOrdering::Greater == QPartialOrdering::Greater);
|
||||
static_assert(Qt::weak_ordering::less == Qt::partial_ordering::less);
|
||||
static_assert(Qt::weak_ordering::equivalent == Qt::partial_ordering::equivalent);
|
||||
static_assert(Qt::weak_ordering::greater == Qt::partial_ordering::greater);
|
||||
|
||||
static_assert(QStrongOrdering::Less == QPartialOrdering::Less);
|
||||
static_assert(QStrongOrdering::Equivalent == QPartialOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Equal == QPartialOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Greater == QPartialOrdering::Greater);
|
||||
static_assert(Qt::strong_ordering::less == Qt::partial_ordering::less);
|
||||
static_assert(Qt::strong_ordering::equivalent == Qt::partial_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::equal == Qt::partial_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::greater == Qt::partial_ordering::greater);
|
||||
|
||||
static_assert(QStrongOrdering::Less == QWeakOrdering::Less);
|
||||
static_assert(QStrongOrdering::Equivalent == QWeakOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Equal == QWeakOrdering::Equivalent);
|
||||
static_assert(QStrongOrdering::Greater == QWeakOrdering::Greater);
|
||||
static_assert(Qt::strong_ordering::less == Qt::weak_ordering::less);
|
||||
static_assert(Qt::strong_ordering::equivalent == Qt::weak_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::equal == Qt::weak_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::greater == Qt::weak_ordering::greater);
|
||||
}
|
||||
#ifdef __cpp_lib_three_way_comparison
|
||||
// QPartialOrdering <-> std::partial_ordering
|
||||
// Qt::partial_ordering <-> std::partial_ordering
|
||||
{
|
||||
static_assert(QPartialOrdering::Less == std::partial_ordering::less);
|
||||
static_assert(QPartialOrdering::Less != std::partial_ordering::greater);
|
||||
static_assert(std::partial_ordering::unordered != QPartialOrdering::Equivalent);
|
||||
static_assert(std::partial_ordering::unordered == QPartialOrdering::Unordered);
|
||||
static_assert(Qt::partial_ordering::less == std::partial_ordering::less);
|
||||
static_assert(Qt::partial_ordering::less != std::partial_ordering::greater);
|
||||
static_assert(std::partial_ordering::unordered != Qt::partial_ordering::equivalent);
|
||||
static_assert(std::partial_ordering::unordered == Qt::partial_ordering::unordered);
|
||||
|
||||
static_assert((QPartialOrdering(std::partial_ordering::less) ==
|
||||
static_assert((Qt::partial_ordering(std::partial_ordering::less) ==
|
||||
std::partial_ordering::less));
|
||||
static_assert((QPartialOrdering(std::partial_ordering::equivalent) ==
|
||||
static_assert((Qt::partial_ordering(std::partial_ordering::equivalent) ==
|
||||
std::partial_ordering::equivalent));
|
||||
static_assert((QPartialOrdering(std::partial_ordering::greater) ==
|
||||
static_assert((Qt::partial_ordering(std::partial_ordering::greater) ==
|
||||
std::partial_ordering::greater));
|
||||
static_assert((QPartialOrdering(std::partial_ordering::unordered) ==
|
||||
static_assert((Qt::partial_ordering(std::partial_ordering::unordered) ==
|
||||
std::partial_ordering::unordered));
|
||||
}
|
||||
// QWeakOrdering <-> std::weak_ordering
|
||||
// Qt::weak_ordering <-> std::weak_ordering
|
||||
{
|
||||
static_assert(QWeakOrdering::Less == std::weak_ordering::less);
|
||||
static_assert(QWeakOrdering::Less != std::weak_ordering::equivalent);
|
||||
static_assert(std::weak_ordering::greater != QWeakOrdering::Less);
|
||||
static_assert(std::weak_ordering::equivalent == QWeakOrdering::Equivalent);
|
||||
static_assert(Qt::weak_ordering::less == std::weak_ordering::less);
|
||||
static_assert(Qt::weak_ordering::less != std::weak_ordering::equivalent);
|
||||
static_assert(std::weak_ordering::greater != Qt::weak_ordering::less);
|
||||
static_assert(std::weak_ordering::equivalent == Qt::weak_ordering::equivalent);
|
||||
|
||||
static_assert((QWeakOrdering(std::weak_ordering::less) ==
|
||||
static_assert((Qt::weak_ordering(std::weak_ordering::less) ==
|
||||
std::weak_ordering::less));
|
||||
static_assert((QWeakOrdering(std::weak_ordering::equivalent) ==
|
||||
static_assert((Qt::weak_ordering(std::weak_ordering::equivalent) ==
|
||||
std::weak_ordering::equivalent));
|
||||
static_assert((QWeakOrdering(std::weak_ordering::greater) ==
|
||||
static_assert((Qt::weak_ordering(std::weak_ordering::greater) ==
|
||||
std::weak_ordering::greater));
|
||||
}
|
||||
// QStrongOrdering <-> std::strong_ordering
|
||||
// Qt::strong_ordering <-> std::strong_ordering
|
||||
{
|
||||
static_assert(QStrongOrdering::Less == std::strong_ordering::less);
|
||||
static_assert(QStrongOrdering::Less != std::strong_ordering::equivalent);
|
||||
static_assert(std::strong_ordering::greater != QStrongOrdering::Less);
|
||||
static_assert(std::strong_ordering::equivalent == QStrongOrdering::Equivalent);
|
||||
static_assert(Qt::strong_ordering::less == std::strong_ordering::less);
|
||||
static_assert(Qt::strong_ordering::less != std::strong_ordering::equivalent);
|
||||
static_assert(std::strong_ordering::greater != Qt::strong_ordering::less);
|
||||
static_assert(std::strong_ordering::equivalent == Qt::strong_ordering::equivalent);
|
||||
|
||||
static_assert((QStrongOrdering(std::strong_ordering::less) ==
|
||||
static_assert((Qt::strong_ordering(std::strong_ordering::less) ==
|
||||
std::strong_ordering::less));
|
||||
static_assert((QStrongOrdering(std::strong_ordering::equivalent) ==
|
||||
static_assert((Qt::strong_ordering(std::strong_ordering::equivalent) ==
|
||||
std::strong_ordering::equivalent));
|
||||
static_assert((QStrongOrdering(std::strong_ordering::greater) ==
|
||||
static_assert((Qt::strong_ordering(std::strong_ordering::greater) ==
|
||||
std::strong_ordering::greater));
|
||||
}
|
||||
// Mixed Q*Ordering <> std::*ordering types
|
||||
// Mixed Qt::*_ordering <> std::*_ordering types
|
||||
{
|
||||
static_assert(QStrongOrdering::Less == std::partial_ordering::less);
|
||||
static_assert(QStrongOrdering::Less != std::partial_ordering::greater);
|
||||
static_assert(QStrongOrdering::Equal == std::weak_ordering::equivalent);
|
||||
static_assert(QStrongOrdering::Equivalent != std::weak_ordering::less);
|
||||
static_assert(Qt::strong_ordering::less == std::partial_ordering::less);
|
||||
static_assert(Qt::strong_ordering::less != std::partial_ordering::greater);
|
||||
static_assert(Qt::strong_ordering::equal == std::weak_ordering::equivalent);
|
||||
static_assert(Qt::strong_ordering::equivalent != std::weak_ordering::less);
|
||||
|
||||
static_assert(QWeakOrdering::Less != std::partial_ordering::greater);
|
||||
static_assert(QWeakOrdering::Less == std::partial_ordering::less);
|
||||
static_assert(QWeakOrdering::Equivalent == std::strong_ordering::equivalent);
|
||||
static_assert(QWeakOrdering::Equivalent != std::strong_ordering::less);
|
||||
static_assert(Qt::weak_ordering::less != std::partial_ordering::greater);
|
||||
static_assert(Qt::weak_ordering::less == std::partial_ordering::less);
|
||||
static_assert(Qt::weak_ordering::equivalent == std::strong_ordering::equivalent);
|
||||
static_assert(Qt::weak_ordering::equivalent != std::strong_ordering::less);
|
||||
|
||||
static_assert(QPartialOrdering::Less != std::weak_ordering::greater);
|
||||
static_assert(QPartialOrdering::Less == std::weak_ordering::less);
|
||||
static_assert(QPartialOrdering::Equivalent == std::strong_ordering::equivalent);
|
||||
static_assert(QPartialOrdering::Equivalent != std::strong_ordering::less);
|
||||
static_assert(Qt::partial_ordering::less != std::weak_ordering::greater);
|
||||
static_assert(Qt::partial_ordering::less == std::weak_ordering::less);
|
||||
static_assert(Qt::partial_ordering::equivalent == std::strong_ordering::equivalent);
|
||||
static_assert(Qt::partial_ordering::equivalent != std::strong_ordering::less);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
@ -1052,29 +1052,29 @@ void tst_QDate::ordering_data()
|
||||
{
|
||||
QTest::addColumn<QDate>("left");
|
||||
QTest::addColumn<QDate>("right");
|
||||
QTest::addColumn<QStrongOrdering>("expectedOrdering");
|
||||
QTest::addColumn<Qt::strong_ordering>("expectedOrdering");
|
||||
|
||||
QTest::newRow("2000-1-2_vs_2000-1-2")
|
||||
<< QDate(2000, 1, 2) << QDate(2000, 1, 2) << QStrongOrdering::Equivalent;
|
||||
<< QDate(2000, 1, 2) << QDate(2000, 1, 2) << Qt::strong_ordering::equivalent;
|
||||
QTest::newRow("2001-12-4_vs_2001-12-5")
|
||||
<< QDate(2001, 12, 4) << QDate(2001, 12, 5) << QStrongOrdering::Less;
|
||||
<< QDate(2001, 12, 4) << QDate(2001, 12, 5) << Qt::strong_ordering::less;
|
||||
QTest::newRow("2001-11-5_vs_2001-12-5")
|
||||
<< QDate(2001, 11, 5) << QDate(2001, 12, 5) << QStrongOrdering::Less;
|
||||
<< QDate(2001, 11, 5) << QDate(2001, 12, 5) << Qt::strong_ordering::less;
|
||||
QTest::newRow("2000-12-5_vs_2001-12-5")
|
||||
<< QDate(2000, 12, 5) << QDate(2001, 12, 5) << QStrongOrdering::Less;
|
||||
<< QDate(2000, 12, 5) << QDate(2001, 12, 5) << Qt::strong_ordering::less;
|
||||
QTest::newRow("2002-12-5_vs_2001-12-5")
|
||||
<< QDate(2002, 12, 5) << QDate(2001, 12, 5) << QStrongOrdering::Greater;
|
||||
<< QDate(2002, 12, 5) << QDate(2001, 12, 5) << Qt::strong_ordering::greater;
|
||||
QTest::newRow("2001-12-5_vs_2001-11-5")
|
||||
<< QDate(2001, 12, 5) << QDate(2001, 11, 5) << QStrongOrdering::Greater;
|
||||
<< QDate(2001, 12, 5) << QDate(2001, 11, 5) << Qt::strong_ordering::greater;
|
||||
QTest::newRow("2001-12-6_vs_2001-12-5")
|
||||
<< QDate(2001, 12, 6) << QDate(2001, 12, 5) << QStrongOrdering::Greater;
|
||||
<< QDate(2001, 12, 6) << QDate(2001, 12, 5) << Qt::strong_ordering::greater;
|
||||
}
|
||||
|
||||
void tst_QDate::ordering()
|
||||
{
|
||||
QFETCH(QDate, left);
|
||||
QFETCH(QDate, right);
|
||||
QFETCH(QStrongOrdering, expectedOrdering);
|
||||
QFETCH(Qt::strong_ordering, expectedOrdering);
|
||||
|
||||
QTestPrivate::testAllComparisonOperators(left, right, expectedOrdering);
|
||||
}
|
||||
@ -1086,42 +1086,42 @@ void tst_QDate::ordering_chrono_types()
|
||||
QDate friday(2001, 11, 30); // the 5th Friday of November 2001
|
||||
// std::chrono::year_month_day
|
||||
QTestPrivate::testAllComparisonOperators(friday, year_month_day(2001y, November, 29d),
|
||||
QStrongOrdering::Greater);
|
||||
Qt::strong_ordering::greater);
|
||||
QTestPrivate::testAllComparisonOperators(friday, year_month_day(2001y, November, 30d),
|
||||
QStrongOrdering::Equivalent);
|
||||
Qt::strong_ordering::equivalent);
|
||||
QTestPrivate::testAllComparisonOperators(friday, year_month_day(2001y, December, 1d),
|
||||
QStrongOrdering::Less);
|
||||
Qt::strong_ordering::less);
|
||||
|
||||
// std::chrono::year_month_day_last
|
||||
QTestPrivate::testAllComparisonOperators(friday, year_month_day_last(2001y, {October / last}),
|
||||
QStrongOrdering::Greater);
|
||||
Qt::strong_ordering::greater);
|
||||
QTestPrivate::testAllComparisonOperators(friday, year_month_day_last(2001y, {November / last}),
|
||||
QStrongOrdering::Equivalent);
|
||||
Qt::strong_ordering::equivalent);
|
||||
QTestPrivate::testAllComparisonOperators(friday, year_month_day_last(2001y, {December / last}),
|
||||
QStrongOrdering::Less);
|
||||
Qt::strong_ordering::less);
|
||||
|
||||
// std::chrono::year_month_weekday
|
||||
QTestPrivate::testAllComparisonOperators(friday,
|
||||
year_month_weekday(2001y, November, Thursday[5]),
|
||||
QStrongOrdering::Greater);
|
||||
Qt::strong_ordering::greater);
|
||||
QTestPrivate::testAllComparisonOperators(friday,
|
||||
year_month_weekday(2001y, November, Friday[5]),
|
||||
QStrongOrdering::Equivalent);
|
||||
Qt::strong_ordering::equivalent);
|
||||
QTestPrivate::testAllComparisonOperators(friday,
|
||||
year_month_weekday(2001y, December, Saturday[1]),
|
||||
QStrongOrdering::Less);
|
||||
Qt::strong_ordering::less);
|
||||
|
||||
// std::chrono::year_month_weekday_last
|
||||
QDate thursday(2001, 11, 29); // the last Thursday of November 2001
|
||||
QTestPrivate::testAllComparisonOperators(thursday, year_month_weekday_last(2001y, November,
|
||||
Wednesday[last]),
|
||||
QStrongOrdering::Greater);
|
||||
Qt::strong_ordering::greater);
|
||||
QTestPrivate::testAllComparisonOperators(thursday, year_month_weekday_last(2001y, November,
|
||||
Thursday[last]),
|
||||
QStrongOrdering::Equivalent);
|
||||
Qt::strong_ordering::equivalent);
|
||||
QTestPrivate::testAllComparisonOperators(thursday, year_month_weekday_last(2001y, November,
|
||||
Friday[last]),
|
||||
QStrongOrdering::Less);
|
||||
Qt::strong_ordering::less);
|
||||
#else
|
||||
QSKIP("This test requires C++20-level <chrono> support enabled in the standard library.");
|
||||
#endif // __cpp_lib_chrono >= 201907L
|
||||
|
||||
@ -2502,7 +2502,7 @@ void tst_QDateTime::ordering_data()
|
||||
{
|
||||
QTest::addColumn<QDateTime>("left");
|
||||
QTest::addColumn<QDateTime>("right");
|
||||
QTest::addColumn<QWeakOrdering>("expectedOrdering");
|
||||
QTest::addColumn<Qt::weak_ordering>("expectedOrdering");
|
||||
|
||||
Q_CONSTINIT static const auto constructName = [](const QDateTime &dt) -> QByteArray {
|
||||
if (dt.isNull())
|
||||
@ -2513,7 +2513,7 @@ void tst_QDateTime::ordering_data()
|
||||
};
|
||||
|
||||
Q_CONSTINIT static const auto generateRow =
|
||||
[](const QDateTime &left, const QDateTime &right, QWeakOrdering ordering) {
|
||||
[](const QDateTime &left, const QDateTime &right, Qt::weak_ordering ordering) {
|
||||
const QByteArray leftStr = constructName(left);
|
||||
const QByteArray rightStr = constructName(right);
|
||||
QTest::addRow("%s_vs_%s", leftStr.constData(), rightStr.constData())
|
||||
@ -2533,25 +2533,25 @@ void tst_QDateTime::ordering_data()
|
||||
epochWest1h.setTimeZone(QTimeZone::fromSecondsAheadOfUtc(-3600));
|
||||
QDateTime local1970(epoch.date(), epoch.time()); // Local time's epoch
|
||||
|
||||
generateRow(june, june, QWeakOrdering::Equivalent);
|
||||
generateRow(june, juneLater, QWeakOrdering::Less);
|
||||
generateRow(june, badDay, QWeakOrdering::Greater);
|
||||
generateRow(badDay, QDateTime(), QWeakOrdering::Equivalent);
|
||||
generateRow(june, QDateTime(), QWeakOrdering::Greater);
|
||||
generateRow(epoch, nextDay, QWeakOrdering::Less);
|
||||
generateRow(epoch, prevDay, QWeakOrdering::Greater);
|
||||
generateRow(epoch, epochEast1h, QWeakOrdering::Equivalent);
|
||||
generateRow(epoch, epochWest1h, QWeakOrdering::Equivalent);
|
||||
generateRow(epochEast1h, epochWest1h, QWeakOrdering::Equivalent);
|
||||
generateRow(june, june, Qt::weak_ordering::equivalent);
|
||||
generateRow(june, juneLater, Qt::weak_ordering::less);
|
||||
generateRow(june, badDay, Qt::weak_ordering::greater);
|
||||
generateRow(badDay, QDateTime(), Qt::weak_ordering::equivalent);
|
||||
generateRow(june, QDateTime(), Qt::weak_ordering::greater);
|
||||
generateRow(epoch, nextDay, Qt::weak_ordering::less);
|
||||
generateRow(epoch, prevDay, Qt::weak_ordering::greater);
|
||||
generateRow(epoch, epochEast1h, Qt::weak_ordering::equivalent);
|
||||
generateRow(epoch, epochWest1h, Qt::weak_ordering::equivalent);
|
||||
generateRow(epochEast1h, epochWest1h, Qt::weak_ordering::equivalent);
|
||||
if (epochTimeType == LocalTimeIsUtc)
|
||||
generateRow(epoch, local1970, QWeakOrdering::Equivalent);
|
||||
generateRow(epoch, local1970, Qt::weak_ordering::equivalent);
|
||||
}
|
||||
|
||||
void tst_QDateTime::ordering()
|
||||
{
|
||||
QFETCH(QDateTime, left);
|
||||
QFETCH(QDateTime, right);
|
||||
QFETCH(QWeakOrdering, expectedOrdering);
|
||||
QFETCH(Qt::weak_ordering, expectedOrdering);
|
||||
|
||||
QTestPrivate::testAllComparisonOperators(left, right, expectedOrdering);
|
||||
}
|
||||
|
||||
@ -362,30 +362,30 @@ void tst_QTime::ordering_data()
|
||||
{
|
||||
QTest::addColumn<QTime>("left");
|
||||
QTest::addColumn<QTime>("right");
|
||||
QTest::addColumn<QStrongOrdering>("expectedOrdering");
|
||||
QTest::addColumn<Qt::strong_ordering>("expectedOrdering");
|
||||
|
||||
auto generateRow = [](QTime t1, QTime t2, QStrongOrdering ordering) {
|
||||
auto generateRow = [](QTime t1, QTime t2, Qt::strong_ordering ordering) {
|
||||
const QByteArray t1Str = t1.toString("hh:mm:ss.zz").toLatin1();
|
||||
const QByteArray t2Str = t2.toString("hh:mm:ss.zz").toLatin1();
|
||||
QTest::addRow("%s_vs_%s", t1Str.constData(), t2Str.constData()) << t1 << t2 << ordering;
|
||||
};
|
||||
|
||||
generateRow(QTime(0, 0), QTime(0, 0), QStrongOrdering::Equivalent);
|
||||
generateRow(QTime(12, 34, 56, 20), QTime(12, 34, 56, 30), QStrongOrdering::Less);
|
||||
generateRow(QTime(13, 34, 46, 20), QTime(13, 34, 56, 20), QStrongOrdering::Less);
|
||||
generateRow(QTime(13, 24, 56, 20), QTime(13, 34, 56, 20), QStrongOrdering::Less);
|
||||
generateRow(QTime(12, 34, 56, 20), QTime(13, 34, 56, 20), QStrongOrdering::Less);
|
||||
generateRow(QTime(14, 34, 56, 20), QTime(13, 34, 56, 20), QStrongOrdering::Greater);
|
||||
generateRow(QTime(13, 44, 56, 20), QTime(13, 34, 56, 20), QStrongOrdering::Greater);
|
||||
generateRow(QTime(13, 34, 56, 20), QTime(13, 34, 46, 20), QStrongOrdering::Greater);
|
||||
generateRow(QTime(13, 34, 56, 30), QTime(13, 34, 56, 20), QStrongOrdering::Greater);
|
||||
generateRow(QTime(0, 0), QTime(0, 0), Qt::strong_ordering::equivalent);
|
||||
generateRow(QTime(12, 34, 56, 20), QTime(12, 34, 56, 30), Qt::strong_ordering::less);
|
||||
generateRow(QTime(13, 34, 46, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::less);
|
||||
generateRow(QTime(13, 24, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::less);
|
||||
generateRow(QTime(12, 34, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::less);
|
||||
generateRow(QTime(14, 34, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::greater);
|
||||
generateRow(QTime(13, 44, 56, 20), QTime(13, 34, 56, 20), Qt::strong_ordering::greater);
|
||||
generateRow(QTime(13, 34, 56, 20), QTime(13, 34, 46, 20), Qt::strong_ordering::greater);
|
||||
generateRow(QTime(13, 34, 56, 30), QTime(13, 34, 56, 20), Qt::strong_ordering::greater);
|
||||
}
|
||||
|
||||
void tst_QTime::ordering()
|
||||
{
|
||||
QFETCH(QTime, left);
|
||||
QFETCH(QTime, right);
|
||||
QFETCH(QStrongOrdering, expectedOrdering);
|
||||
QFETCH(Qt::strong_ordering, expectedOrdering);
|
||||
|
||||
QTestPrivate::testAllComparisonOperators(left, right, expectedOrdering);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user