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 c6fe64b17c87ec985f17389bf08eee46606862d4, 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>

3 files changed, 47 insertions, 47 deletions

diff --git a/tests/auto/corelib/time/qdate/tst_qdate.cpp b/tests/auto/corelib/time/qdate/tst_qdate.cpp
index 4b3698e18c..235c7eec03 100644
--- a/tests/auto/corelib/time/qdate/tst_qdate.cpp
+++ b/tests/auto/corelib/time/qdate/tst_qdate.cpp
@@ -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
diff --git a/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp b/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp
index 5f6cea2e3a..5a6efc116e 100644
--- a/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp
+++ b/tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp
@@ -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);
 }
diff --git a/tests/auto/corelib/time/qtime/tst_qtime.cpp b/tests/auto/corelib/time/qtime/tst_qtime.cpp
index d9d3698ef6..c1cb5d7d40 100644
--- a/tests/auto/corelib/time/qtime/tst_qtime.cpp
+++ b/tests/auto/corelib/time/qtime/tst_qtime.cpp
@@ -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);
 }