qcompare.qdoc

Go to the documentation of this file.

// Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
 
/*!
    \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 greater than 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,
    // and a compare function declared as follows:
 
    QPartialOrdering compare(T lhs, T rhs); // defined out-of-line
    ~~~
 
    QPartialOrdering 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 QPartialOrdering value which represents an unordered result will
    always return false when compared against literal 0.
*/
 
/*!
    \fn bool QPartialOrdering::operator==(QPartialOrdering lhs, QPartialOrdering rhs)
 
    Return true if \a lhs and \a rhs represent the same result;
    otherwise, returns false.
*/
 
/*!
    \fn bool QPartialOrdering::operator!=(QPartialOrdering lhs, QPartialOrdering rhs)
 
    Return true if \a lhs and \a rhs represent different results;
    otherwise, returns true.
*/
 
/*!
    \fn bool operator==(QPartialOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
    \fn bool operator!=(QPartialOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
    \fn bool operator< (QPartialOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
    \fn bool operator<=(QPartialOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
    \fn bool operator> (QPartialOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
    \fn bool operator>=(QPartialOrdering lhs, QtPrivate::CompareAgainstLiteralZero)
 
    \fn bool operator==(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering rhs)
    \fn bool operator!=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering rhs)
    \fn bool operator< (QtPrivate::CompareAgainstLiteralZero, QPartialOrdering rhs)
    \fn bool operator<=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering rhs)
    \fn bool operator> (QtPrivate::CompareAgainstLiteralZero, QPartialOrdering rhs)
    \fn bool operator>=(QtPrivate::CompareAgainstLiteralZero, QPartialOrdering rhs)
    \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 the 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 the 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 the 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 the right hand
    side.
*/