/**************************************************************************** | |
** | |
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). | |
** All rights reserved. | |
** Contact: Nokia Corporation (qt-info@nokia.com) | |
** | |
** This file is part of the documentation of the Qt Toolkit. | |
** | |
** $QT_BEGIN_LICENSE:FDL$ | |
** GNU Free Documentation License | |
** 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. | |
** | |
** Other Usage | |
** Alternatively, this file may be used in accordance with the terms | |
** and conditions contained in a signed written agreement between you | |
** and Nokia. | |
** | |
** | |
** | |
** | |
** $QT_END_LICENSE$ | |
** | |
****************************************************************************/ | |
/*! | |
\class QPair | |
\brief The QPair class is a template class that stores a pair of items. | |
\ingroup tools | |
QPair\<T1, T2\> can be used in your application if the STL \c | |
pair type is not available. It stores one value of type T1 and | |
one value of type T2. It can be used as a return value for a | |
function that needs to return two values, or as the value type of | |
a \l{Container classes}{generic container}. | |
Here's an example of a QPair that stores one QString and one \c | |
double value: | |
\snippet doc/src/snippets/code/doc_src_qpair.cpp 0 | |
The components are accessible as public data members called \l | |
first and \l second. For example: | |
\snippet doc/src/snippets/code/doc_src_qpair.cpp 1 | |
QPair's template data types (T1 and T2) must be \l{assignable | |
data types}. You cannot, for example, store a QWidget as a value; | |
instead, store a QWidget *. A few functions have additional | |
requirements; these requirements are documented on a per-function | |
basis. | |
\sa {Container Classes} | |
*/ | |
/*! \typedef QPair::first_type | |
The type of the first element in the pair (T1). | |
\sa first | |
*/ | |
/*! \typedef QPair::second_type | |
The type of the second element in the pair (T2). | |
\sa second | |
*/ | |
/*! \variable QPair::first | |
The first element in the pair. | |
*/ | |
/*! \variable QPair::second | |
The second element in the pair. | |
*/ | |
/*! \fn QPair::QPair() | |
Constructs an empty pair. The \c first and \c second elements are | |
initialized with \l{default-constructed values}. | |
*/ | |
/*! | |
\fn QPair::QPair(const T1 &value1, const T2 &value2) | |
Constructs a pair and initializes the \c first element with \a | |
value1 and the \c second element with \a value2. | |
\sa qMakePair() | |
*/ | |
/*! | |
\fn QPair<T1, T2> &QPair::operator=(const QPair<T1, T2> &other) | |
Assigns \a other to this pair. | |
*/ | |
/*! \fn bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
\relates QPair | |
Returns true if \a p1 is equal to \a p2; otherwise returns false. | |
Two pairs compare equal if their \c first data members compare | |
equal and if their \c second data members compare equal. | |
This function requires the T1 and T2 types to have an | |
implementation of \c operator==(). | |
*/ | |
/*! \fn bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
\relates QPair | |
Returns true if \a p1 is not equal to \a p2; otherwise returns | |
false. Two pairs compare as not equal if their \c first data | |
members are not equal or if their \c second data members are not | |
equal. | |
This function requires the T1 and T2 types to have an | |
implementation of \c operator==(). | |
*/ | |
/*! \fn bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
\relates QPair | |
Returns true if \a p1 is less than \a p2; otherwise returns | |
false. The comparison is done on the \c first members of \a p1 | |
and \a p2; if they compare equal, the \c second members are | |
compared to break the tie. | |
This function requires the T1 and T2 types to have an | |
implementation of \c operator<(). | |
*/ | |
/*! \fn bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
\relates QPair | |
Returns true if \a p1 is greater than \a p2; otherwise returns | |
false. The comparison is done on the \c first members of \a p1 | |
and \a p2; if they compare equal, the \c second members are | |
compared to break the tie. | |
This function requires the T1 and T2 types to have an | |
implementation of \c operator<(). | |
*/ | |
/*! \fn bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
\relates QPair | |
Returns true if \a p1 is less than or equal to \a p2; otherwise | |
returns false. The comparison is done on the \c first members of | |
\a p1 and \a p2; if they compare equal, the \c second members are | |
compared to break the tie. | |
This function requires the T1 and T2 types to have an | |
implementation of \c operator<(). | |
*/ | |
/*! \fn bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
\relates QPair | |
Returns true if \a p1 is greater than or equal to \a p2; | |
otherwise returns false. The comparison is done on the \c first | |
members of \a p1 and \a p2; if they compare equal, the \c second | |
members are compared to break the tie. | |
This function requires the T1 and T2 types to have an | |
implementation of \c operator<(). | |
*/ | |
/*! | |
\fn QPair<T1, T2> qMakePair(const T1 &value1, const T2 &value2) | |
\relates QPair | |
Returns a QPair\<T1, T2\> that contains \a value1 and \a value2. | |
Example: | |
\snippet doc/src/snippets/code/doc_src_qpair.cpp 2 | |
This is equivalent to QPair<T1, T2>(\a value1, \a value2), but | |
usually requires less typing. | |
*/ | |
/*! \fn QDataStream &operator>>(QDataStream &in, QPair<T1, T2> &pair) | |
\relates QPair | |
Reads a pair from stream \a in into \a pair. | |
This function requires the T1 and T2 types to implement \c operator>>(). | |
\sa {Serializing Qt Data Types} | |
*/ | |
/*! \fn QDataStream &operator<<(QDataStream &out, const QPair<T1, T2> &pair) | |
\relates QPair | |
Writes the pair \a pair to stream \a out. | |
This function requires the T1 and T2 types to implement \c operator<<(). | |
\sa {Serializing Qt Data Types} | |
*/ |