From 8e98a161e993c6636d217276a0f2373d642ff050 Mon Sep 17 00:00:00 2001 From: Giuseppe D'Angelo Date: Sat, 15 Feb 2020 00:11:22 +0100 Subject: Long live std::pair! Make QPair an alias for std::pair, and qMakePair just a forwarder towards std::make_pair. Why? Fundamentally to ditch a bunch of NIH code; gain for free structured bindings, std::tuple and std::reference_wrapper compatibility, and so on. Breakages: * Some that code manually forward declares QPair. We don't care about it ( is the proper way). * Some code that overloads on std::pair and QPair. Luckily it's mostly centralized: debug, metatypes, testing macros. Just remove the QPair overload. * Usages of qMakePair forcing the template type parameters. There are a handful of these in qtbase, but only one was actually broken. * std::pair is NOT (and will never likely be) trivially copiable. This is agreed to be a mistake done by practically all implementations in C++11, can can't be fixed without breaking ABI. Some code using QPair assuming it's trivially copiable may break; exactly one occurrence was in qtbase. * QMetaType logic extracts the type names in two different ways, one by looking at the source code string (e.g. extracted by moc) and one via some ad-hoc reflection in C++. We need to make "QPair" (as spelled in the source code) be the same as "std::pair" (gathered via reflection, which will see through the alias) when compared. The way it's already done e.g. for QList is by actually replacing the moc-extracted name with the name of the actual type used in C++; do the same here. On libc++, std::pair is actually in an inline namespace -- i.e. std::__1::pair; the reflection will extract and store "std::__1::pair" so we need an ad-hoc fix to QMetaType. [ChangeLog][QtCore][QPair] QPair is now an alias to std::pair, and does not exist as a class in Qt any more. This may break code such as functions overloaded for both QPair and std::pair. Usually, the overload taking a QPair can be safely discarded, leaving only the one taking a std::pair. QPair API has not changed, and qMakePair is still available for compatibility (although new code is encouraged to use std::pair and std::make_pair directly instead). Change-Id: I7725c751bf23946cde577b1406e86a336c0a3dcf Reviewed-by: Lars Knoll --- src/corelib/tools/qcontainerfwd.h | 3 +- src/corelib/tools/qhashfunctions.h | 9 -- src/corelib/tools/qpair.h | 111 ++-------------- src/corelib/tools/qpair.qdoc | 251 ++----------------------------------- 4 files changed, 21 insertions(+), 353 deletions(-) (limited to 'src/corelib/tools') diff --git a/src/corelib/tools/qcontainerfwd.h b/src/corelib/tools/qcontainerfwd.h index bdf9e0dcc0..fd4701a8b1 100644 --- a/src/corelib/tools/qcontainerfwd.h +++ b/src/corelib/tools/qcontainerfwd.h @@ -50,7 +50,8 @@ template class QHash; template class QMap; template class QMultiHash; template class QMultiMap; -template struct QPair; +template +using QPair = std::pair; template class QQueue; template class QSet; template class QStack; diff --git a/src/corelib/tools/qhashfunctions.h b/src/corelib/tools/qhashfunctions.h index 5742540061..38e799e78b 100644 --- a/src/corelib/tools/qhashfunctions.h +++ b/src/corelib/tools/qhashfunctions.h @@ -252,15 +252,6 @@ inline size_t qHashRangeCommutative(InputIterator first, InputIterator last, siz return std::accumulate(first, last, seed, QtPrivate::QHashCombineCommutative()); } -template inline size_t qHash(const QPair &key, size_t seed = 0) - noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed))) -{ - QtPrivate::QHashCombine hash; - seed = hash(seed, key.first); - seed = hash(seed, key.second); - return seed; -} - template inline size_t qHash(const std::pair &key, size_t seed = 0) noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed))) { diff --git a/src/corelib/tools/qpair.h b/src/corelib/tools/qpair.h index 9ebf88bc8f..6cb7fc5079 100644 --- a/src/corelib/tools/qpair.h +++ b/src/corelib/tools/qpair.h @@ -44,115 +44,22 @@ QT_BEGIN_NAMESPACE - -template -struct QPair -{ - typedef T1 first_type; - typedef T2 second_type; - - Q_DECL_CONSTEXPR QPair() - noexcept((std::is_nothrow_default_constructible::value && - std::is_nothrow_default_constructible::value)) - : first(), second() {} - Q_DECL_CONSTEXPR QPair(const T1 &t1, const T2 &t2) - noexcept((std::is_nothrow_copy_constructible::value && - std::is_nothrow_copy_constructible::value)) - : first(t1), second(t2) {} - // compiler-generated copy/move ctor/assignment operators are fine! - - template - Q_DECL_CONSTEXPR QPair(const QPair &p) - noexcept((std::is_nothrow_constructible::value && - std::is_nothrow_constructible::value)) - : first(p.first), second(p.second) {} - template - Q_DECL_RELAXED_CONSTEXPR QPair &operator=(const QPair &p) - noexcept((std::is_nothrow_assignable::value && - std::is_nothrow_assignable::value)) - { first = p.first; second = p.second; return *this; } - template - Q_DECL_CONSTEXPR QPair(QPair &&p) - noexcept((std::is_nothrow_constructible::value && - std::is_nothrow_constructible::value)) - // can't use std::move here as it's not constexpr in C++11: - : first(static_cast(p.first)), second(static_cast(p.second)) {} - template - Q_DECL_RELAXED_CONSTEXPR QPair &operator=(QPair &&p) - noexcept((std::is_nothrow_assignable::value && - std::is_nothrow_assignable::value)) - { first = std::move(p.first); second = std::move(p.second); return *this; } - - Q_DECL_RELAXED_CONSTEXPR void swap(QPair &other) - noexcept(noexcept(qSwap(other.first, other.first)) && noexcept(qSwap(other.second, other.second))) - { - // use qSwap() to pick up ADL swaps automatically: - qSwap(first, other.first); - qSwap(second, other.second); - } - - T1 first; - T2 second; -}; - -#if defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201606 -template -QPair(T1, T2) -> QPair; +#if 0 +#pragma qt_class(QPair) #endif template -void swap(QPair &lhs, QPair &rhs) noexcept(noexcept(lhs.swap(rhs))) -{ lhs.swap(rhs); } - -// mark QPair as complex/movable/primitive depending on the -// typeinfos of the constituents: -template -class QTypeInfo > : public QTypeInfoMerger, T1, T2> {}; // Q_DECLARE_TYPEINFO +using QPair = std::pair; -template -Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator==(const QPair &p1, const QPair &p2) - noexcept(noexcept(p1.first == p2.first && p1.second == p2.second)) -{ return p1.first == p2.first && p1.second == p2.second; } - -template -Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator!=(const QPair &p1, const QPair &p2) - noexcept(noexcept(!(p1 == p2))) -{ return !(p1 == p2); } - -template -Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator<(const QPair &p1, const QPair &p2) - noexcept(noexcept(p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second))) -{ - return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second); -} - -template -Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator>(const QPair &p1, const QPair &p2) - noexcept(noexcept(p2 < p1)) -{ - return p2 < p1; -} - -template -Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator<=(const QPair &p1, const QPair &p2) - noexcept(noexcept(!(p2 < p1))) -{ - return !(p2 < p1); -} - -template -Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator>=(const QPair &p1, const QPair &p2) - noexcept(noexcept(!(p1 < p2))) +template +constexpr decltype(auto) qMakePair(T1 &&value1, T2 &&value2) + noexcept(noexcept(std::make_pair(std::forward(value1), std::forward(value2)))) { - return !(p1 < p2); + return std::make_pair(std::forward(value1), std::forward(value2)); } -template -Q_DECL_CONSTEXPR Q_OUTOFLINE_TEMPLATE QPair qMakePair(const T1 &x, const T2 &y) - noexcept(noexcept(QPair(x, y))) -{ - return QPair(x, y); -} +template +class QTypeInfo> : public QTypeInfoMerger, T1, T2> {}; QT_END_NAMESPACE diff --git a/src/corelib/tools/qpair.qdoc b/src/corelib/tools/qpair.qdoc index 65576ef2e6..0e17b6c3b9 100644 --- a/src/corelib/tools/qpair.qdoc +++ b/src/corelib/tools/qpair.qdoc @@ -28,255 +28,24 @@ /*! \class QPair \inmodule QtCore - \reentrant - \brief The QPair class is a template class that stores a pair of items. + \obsolete + \brief QPair is an alias for std::pair. \ingroup tools - QPair\ 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 code/doc_src_qpair.cpp 0 - - The components are accessible as public data members called \l - first and \l second. For example: - - \snippet code/doc_src_qpair.cpp 1 - - Note, however, that it is almost always preferable to define a small struct - to hold the result of a function with multiple return values. A struct - trivially generalizes to more than two values, and allows more descriptive - member names than \c{first} and \c{second}: - - \snippet code/doc_src_qpair.cpp struct - - The advent of C++11 automatic variable type deduction (\c{auto}) shifts the - emphasis from the type name to the name of functions and members. Thus, QPair, - like \c{std::pair} and \c{std::tuple}, is mostly useful in generic (template) - code, where defining a dedicated type is not possible. - - 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. + QPair\ is a typedef for std::pair\. + It is provided for backwards compatibility. Use std::pair directly + instead. \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 template QPair::QPair() - - Constructs an empty pair. The \c first and \c second elements are - initialized with \l{default-constructed value}s. -*/ - -/*! - \fn template 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 template void QPair::swap(QPair &other) - - \since 5.5 - Swaps this pair with \a other. - - Equivalent to - \code - qSwap(this->first, other.first); - qSwap(this->second, other.second); - \endcode - - Swap overloads are found in namespace \c std as well as via - argument-dependent lookup (ADL) in the namespace of \c{T} . -*/ - -/*! -\fn template void swap(QPair &lhs, QPair &rhs) - \overload - \relates QPair - \since 5.5 - - Swaps \a lhs with \a rhs. -*/ - -/*! - \fn template template QPair::QPair(const QPair &p) - \since 5.2 - - Constructs a pair from the other pair \a p, of types TT1 and TT2. This - constructor will fail if \c first cannot be initialized from \c p.first or - if \c second cannot be initialized from \c p.second. - - \sa qMakePair() -*/ - -/*! - \fn template template QPair::QPair(QPair &&p) - \since 5.2 - - Move-constructs a QPair instance, making it point to the same object that \a p was pointing to. -*/ - -/*! - \fn template template QPair & QPair::operator=(const QPair &p) - \since 5.2 - - Copies pair \a p into this pair. - - \sa qMakePair() -*/ - -/*! - \fn template template QPair & QPair::operator=(QPair &&p) - \since 5.2 - - Move-assigns pair \a p into this pair instance. -*/ - -/*! \fn template bool operator==(const QPair &p1, const QPair &p2) - - \relates QPair - - Returns \c true if \a p1 is equal to \a p2; otherwise returns \c 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 template bool operator!=(const QPair &p1, const QPair &p2) - - \relates QPair - - Returns \c 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 template bool operator<(const QPair &p1, const QPair &p2) - - \relates QPair - - Returns \c 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 template bool operator>(const QPair &p1, const QPair &p2) - - \relates QPair - - Returns \c 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 template bool operator<=(const QPair &p1, const QPair &p2) - - \relates QPair - - Returns \c true if \a p1 is less than or equal to \a p2; otherwise - returns \c 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 template bool operator>=(const QPair &p1, const QPair &p2) - - \relates QPair - - Returns \c true if \a p1 is greater than or equal to \a p2; - otherwise returns \c 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 template QPair qMakePair(const T1 &value1, const T2 &value2) - - \relates QPair - - Returns a QPair\ that contains \a value1 and \a value2. - Example: - - \snippet code/doc_src_qpair.cpp 2 - - This is equivalent to QPair(\a value1, \a value2), but - usually requires less typing. -*/ - -/*! \fn template QDataStream &operator>>(QDataStream &in, QPair &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 template QDataStream &operator<<(QDataStream &out, const QPair &pair) - + \fn template QPair qMakePair(T1 &&value1, T2 &&value2) + \obsolete \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} + qMakePair forwards its arguments to std::make_pair, and returns + the resulting std::pair. It is provided for backwards compatibility. + Use std::make_pair directly instead. */ -- cgit v1.2.3