1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/****************************************************************************
**
** 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 QPartialOrdering::operator==(QPartialOrdering p1, QPartialOrdering p2) noexcept
Return true if \a p1 and \a p2 represent the same result;
otherwise, returns false.
*/
/*!
\fn bool QPartialOrdering::operator!=(QPartialOrdering p1, QPartialOrdering p2) noexcept
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
*/
/*!
\variable QPartialOrdering::Less
Represents the result of a comparison where the value on the left
hand side is less than the value on right hand side.
*/
/*!
\variable QPartialOrdering::Equivalent
Represents the result of a comparison where the value on the left
hand side is equivalent to the value on right hand side.
*/
/*!
\variable QPartialOrdering::Greater
Represents the result of a comparison where the value on the left
hand side is greater than the value on right hand side.
*/
/*!
\variable QPartialOrdering::Unordered
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.
*/
|