summaryrefslogtreecommitdiffstats
path: root/src/corelib/global
diff options
context:
space:
mode:
Diffstat (limited to 'src/corelib/global')
-rw-r--r--src/corelib/global/global.pri1
-rw-r--r--src/corelib/global/qcompare.h143
-rw-r--r--src/corelib/global/qcompare.qdoc147
3 files changed, 291 insertions, 0 deletions
diff --git a/src/corelib/global/global.pri b/src/corelib/global/global.pri
index 4e9a0a0c8b..23b5a284ce 100644
--- a/src/corelib/global/global.pri
+++ b/src/corelib/global/global.pri
@@ -5,6 +5,7 @@ HEADERS += \
global/qoperatingsystemversion.h \
global/qoperatingsystemversion_p.h \
global/qsystemdetection.h \
+ global/qcompare.h \
global/qcompilerdetection.h \
global/qcontainerinfo.h \
global/qprocessordetection.h \
diff --git a/src/corelib/global/qcompare.h b/src/corelib/global/qcompare.h
new file mode 100644
index 0000000000..07f4589984
--- /dev/null
+++ b/src/corelib/global/qcompare.h
@@ -0,0 +1,143 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCOMPARE_H
+#define QCOMPARE_H
+
+#if 0
+#pragma qt_class(QtCompare)
+#endif
+
+#include <QtCore/qglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace QtPrivate {
+using CompareUnderlyingType = qint8;
+
+// [cmp.categories.pre] / 1
+enum class Ordering : CompareUnderlyingType
+{
+ Equal = 0,
+ Equivalent = Equal,
+ Less = -1,
+ Greater = 1
+};
+
+enum class Uncomparable : CompareUnderlyingType
+{
+ Unordered = -127
+};
+
+// [cmp.categories.pre] / 3, but using a safe bool trick
+// and also rejecting std::nullptr_t (unlike the example)
+class CompareAgainstLiteralZero {
+public:
+ using SafeZero = void (CompareAgainstLiteralZero::*)();
+ Q_IMPLICIT constexpr CompareAgainstLiteralZero(SafeZero) noexcept {}
+
+ template <typename T, std::enable_if_t<!std::is_same_v<T, int>, bool> = false>
+ CompareAgainstLiteralZero(T) = delete;
+};
+} // namespace QtPrivate
+
+// [cmp.partialord]
+class QPartialOrdering
+{
+public:
+ static const QPartialOrdering Less;
+ static const QPartialOrdering Equivalent;
+ static const QPartialOrdering Greater;
+ static const QPartialOrdering Unordered;
+
+ friend constexpr bool operator==(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ { return p.isOrdered() && p.m_order == 0; }
+ friend constexpr bool operator!=(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ { return p.isOrdered() && p.m_order != 0; }
+ friend constexpr bool operator< (QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ { return p.isOrdered() && p.m_order < 0; }
+ friend constexpr bool operator<=(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ { return p.isOrdered() && p.m_order <= 0; }
+ friend constexpr bool operator> (QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ { return p.isOrdered() && p.m_order > 0; }
+ friend constexpr bool operator>=(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ { return p.isOrdered() && p.m_order >= 0; }
+
+ friend constexpr bool operator==(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ { return p.isOrdered() && 0 == p.m_order; }
+ friend constexpr bool operator!=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ { return p.isOrdered() && 0 != p.m_order; }
+ friend constexpr bool operator< (QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ { return p.isOrdered() && 0 < p.m_order; }
+ friend constexpr bool operator<=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ { return p.isOrdered() && 0 <= p.m_order; }
+ friend constexpr bool operator> (QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ { return p.isOrdered() && 0 > p.m_order; }
+ friend constexpr bool operator>=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ { return p.isOrdered() && 0 >= p.m_order; }
+
+ friend constexpr bool operator==(QPartialOrdering p1, QPartialOrdering p2) noexcept
+ { return p1.m_order == p2.m_order; }
+ friend constexpr bool operator!=(QPartialOrdering p1, QPartialOrdering p2) noexcept
+ { return p1.m_order != p2.m_order; }
+
+private:
+ constexpr explicit QPartialOrdering(QtPrivate::Ordering order) noexcept
+ : m_order(static_cast<QtPrivate::CompareUnderlyingType>(order))
+ {}
+ constexpr explicit QPartialOrdering(QtPrivate::Uncomparable order) noexcept
+ : m_order(static_cast<QtPrivate::CompareUnderlyingType>(order))
+ {}
+
+ // instead of the exposition only is_ordered member in [cmp.partialord],
+ // use a private function
+ constexpr bool isOrdered() noexcept
+ { return m_order != static_cast<QtPrivate::CompareUnderlyingType>(QtPrivate::Uncomparable::Unordered); }
+
+ QtPrivate::CompareUnderlyingType m_order;
+};
+
+inline constexpr QPartialOrdering QPartialOrdering::Less(QtPrivate::Ordering::Less);
+inline constexpr QPartialOrdering QPartialOrdering::Equivalent(QtPrivate::Ordering::Equivalent);
+inline constexpr QPartialOrdering QPartialOrdering::Greater(QtPrivate::Ordering::Greater);
+inline constexpr QPartialOrdering QPartialOrdering::Unordered(QtPrivate::Uncomparable::Unordered);
+
+QT_END_NAMESPACE
+
+#endif // QCOMPARE_H
diff --git a/src/corelib/global/qcompare.qdoc b/src/corelib/global/qcompare.qdoc
new file mode 100644
index 0000000000..80d402f67c
--- /dev/null
+++ b/src/corelib/global/qcompare.qdoc
@@ -0,0 +1,147 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the documentation of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:FDL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Free Documentation License Usage
+** Alternatively, this file may be used under the terms of the GNU Free
+** Documentation License version 1.3 as published by the Free Software
+** Foundation and appearing in the file included in the packaging of
+** this file. Please review the following information to ensure
+** the GNU Free Documentation License version 1.3 requirements
+** will be met: https://www.gnu.org/licenses/fdl-1.3.html.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+ \class QPartialOrdering
+ \inmodule QtCore
+ \brief QPartialOrdering represents the result of a comparison that allows for unordered results.
+ \since 6.0
+
+ A value of type QPartialOrdering 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
+ QPartialOrdering value returned from the comparison function
+ represents one of those possibilities.
+
+ The possible values of type QPartialOrdering are, in fact, fully
+ represented by the following four static values:
+
+ \list
+
+ \li \c QPartialOrdering::Less represents that the first object is
+ less than the second;
+
+ \li \c QPartialOrdering::Equivalent represents that the first
+ object is equivalent to the second;
+
+ \li \c QPartialOrdering::Greater represents that the first object
+ is equivalent to the second;
+
+ \li \c QPartialOrdering::Unordered represents that the first object
+ is \e{not ordered} with respect to the second.
+
+ \endlist
+
+ QPartialOrdering 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
+
+ QPartialOrdering result = a.compare(b);
+ if (result < 0) {
+ // a is less than b
+ }
+
+ if (c.compare(d) >= 0) {
+ // c is greater than or equal to d
+ }
+
+ \endcode
+
+ A QPartialOrdering value which represents an unordered result will
+ always return false when compared against literal 0.
+*/
+
+/*!
+ \fn bool operator==(QPartialOrdering p1, QPartialOrdering p2) noexcept
+ \relates QPartialOrdering
+
+ Return true if \a p1 and \a p2 represent the same result;
+ otherwise, returns false.
+*/
+
+/*!
+ \fn bool operator!=(QPartialOrdering p1, QPartialOrdering p2) noexcept
+ \relates QPartialOrdering
+
+ Return true if \a p1 and \a p2 represent different results;
+ otherwise, returns true.
+*/
+
+/*!
+ \fn bool operator==(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ \fn bool operator!=(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ \fn bool operator< (QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ \fn bool operator<=(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ \fn bool operator> (QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+ \fn bool operator>=(QPartialOrdering p, QtPrivate::CompareAgainstLiteralZero) noexcept
+
+ \fn bool operator==(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ \fn bool operator!=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ \fn bool operator< (QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ \fn bool operator<=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ \fn bool operator> (QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ \fn bool operator>=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering p) noexcept
+ \relates QPartialOrdering
+ \internal
+*/
+
+/*!
+ \value QPartialOrdering::Less
+ \relates QPartialOrdering
+
+ Represents the result of a comparison where the value on the left
+ hand side is less than the value on right hand side.
+*/
+
+/*!
+ \value QPartialOrdering::Equivalent
+ \relates QPartialOrdering
+
+ Represents the result of a comparison where the value on the left
+ hand side is equivalent to the value on right hand side.
+*/
+
+/*!
+ \value QPartialOrdering::Greater
+ \relates QPartialOrdering
+
+ Represents the result of a comparison where the value on the left
+ hand side is greater than the value on right hand side.
+*/
+
+/*!
+ \value QPartialOrdering::Unordered
+ \relates QPartialOrdering
+
+ Represents the result of a comparison where the value on the left
+ hand side is not ordered with respect to the value on right hand
+ side.
+*/
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-18 20:36:03 +0000