diff options
Diffstat (limited to 'src/corelib/tools/qhashfunctions.h')
| -rw-r--r-- | src/corelib/tools/qhashfunctions.h | 405 |
1 files changed, 301 insertions, 104 deletions
diff --git a/src/corelib/tools/qhashfunctions.h b/src/corelib/tools/qhashfunctions.h index 2ff3464912..90a269deaa 100644 --- a/src/corelib/tools/qhashfunctions.h +++ b/src/corelib/tools/qhashfunctions.h @@ -1,51 +1,21 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Copyright (C) 2015 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com> -** Contact: https://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$ -** -****************************************************************************/ +// Copyright (C) 2016 The Qt Company Ltd. +// Copyright (C) 2015 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com> +// Copyright (C) 2024 Intel Corporation. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #ifndef QHASHFUNCTIONS_H #define QHASHFUNCTIONS_H #include <QtCore/qstring.h> -#include <QtCore/qpair.h> +#include <QtCore/qstringfwd.h> #include <numeric> // for std::accumulate #include <functional> // for std::hash +#include <utility> // For std::pair + +#ifdef __cpp_concepts +# include <concepts> +#endif #if 0 #pragma qt_class(QHashFunctions) @@ -60,117 +30,342 @@ QT_BEGIN_NAMESPACE class QBitArray; -class QByteArray; -class QString; -class QStringRef; -class QLatin1String; +#if QT_DEPRECATED_SINCE(6,6) +QT_DEPRECATED_VERSION_X_6_6("Use QHashSeed instead") Q_CORE_EXPORT int qGlobalQHashSeed(); +QT_DEPRECATED_VERSION_X_6_6("Use QHashSeed instead") Q_CORE_EXPORT void qSetGlobalQHashSeed(int newSeed); +#endif + +struct QHashSeed +{ + constexpr QHashSeed(size_t d = 0) : data(d) {} + constexpr operator size_t() const noexcept { return data; } + + static Q_CORE_EXPORT QHashSeed globalSeed() noexcept; + static Q_CORE_EXPORT void setDeterministicGlobalSeed(); + static Q_CORE_EXPORT void resetRandomGlobalSeed(); +private: + size_t data; +}; + +// Whether, ∀ t of type T && ∀ seed, qHash(Key(t), seed) == qHash(t, seed) +template <typename Key, typename T> struct QHashHeterogeneousSearch : std::false_type {}; + +// Specializations +template <> struct QHashHeterogeneousSearch<QString, QStringView> : std::true_type {}; +template <> struct QHashHeterogeneousSearch<QStringView, QString> : std::true_type {}; +template <> struct QHashHeterogeneousSearch<QByteArray, QByteArrayView> : std::true_type {}; +template <> struct QHashHeterogeneousSearch<QByteArrayView, QByteArray> : std::true_type {}; +#ifndef Q_PROCESSOR_ARM +template <> struct QHashHeterogeneousSearch<QString, QLatin1StringView> : std::true_type {}; +template <> struct QHashHeterogeneousSearch<QStringView, QLatin1StringView> : std::true_type {}; +template <> struct QHashHeterogeneousSearch<QLatin1StringView, QString> : std::true_type {}; +template <> struct QHashHeterogeneousSearch<QLatin1StringView, QStringView> : std::true_type {}; +#endif + +namespace QHashPrivate { + +Q_DECL_CONST_FUNCTION constexpr size_t hash(size_t key, size_t seed) noexcept +{ + key ^= seed; + if constexpr (sizeof(size_t) == 4) { + key ^= key >> 16; + key *= UINT32_C(0x45d9f3b); + key ^= key >> 16; + key *= UINT32_C(0x45d9f3b); + key ^= key >> 16; + return key; + } else { + quint64 key64 = key; + key64 ^= key64 >> 32; + key64 *= UINT64_C(0xd6e8feb86659fd93); + key64 ^= key64 >> 32; + key64 *= UINT64_C(0xd6e8feb86659fd93); + key64 ^= key64 >> 32; + return size_t(key64); + } +} + +template <typename T1, typename T2> static constexpr bool noexceptPairHash(); +} -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qHashBits(const void *p, size_t size, uint seed = 0) noexcept; +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHashBits(const void *p, size_t size, size_t seed = 0) noexcept; -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(char key, uint seed = 0) noexcept { return uint(key) ^ seed; } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(uchar key, uint seed = 0) noexcept { return uint(key) ^ seed; } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(signed char key, uint seed = 0) noexcept { return uint(key) ^ seed; } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(ushort key, uint seed = 0) noexcept { return uint(key) ^ seed; } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(short key, uint seed = 0) noexcept { return uint(key) ^ seed; } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(uint key, uint seed = 0) noexcept { return key ^ seed; } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(int key, uint seed = 0) noexcept { return uint(key) ^ seed; } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(ulong key, uint seed = 0) noexcept +// implementation below qHashMulti +template <typename T1, typename T2> inline size_t qHash(const std::pair<T1, T2> &key, size_t seed = 0) + noexcept(QHashPrivate::noexceptPairHash<T1, T2>()); + +// C++ builtin types +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(char key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(uchar key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(signed char key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(ushort key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(short key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(uint key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(int key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(ulong key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(long key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(quint64 key, size_t seed = 0) noexcept +{ + if constexpr (sizeof(quint64) > sizeof(size_t)) + key ^= (key >> 32); + return QHashPrivate::hash(size_t(key), seed); +} +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(qint64 key, size_t seed = 0) noexcept +{ + if constexpr (sizeof(qint64) > sizeof(size_t)) { + // Avoid QTBUG-116080: we XOR the top half with its own sign bit: + // - if the qint64 is in range of qint32, then signmask ^ high == 0 + // (for Qt 7 only) + // - if the qint64 is in range of quint32, then signmask == 0 and we + // do the same as the quint64 overload above + quint32 high = quint32(quint64(key) >> 32); + quint32 low = quint32(quint64(key)); + quint32 signmask = qint32(high) >> 31; // all zeroes or all ones + signmask = QT_VERSION_MAJOR > 6 ? signmask : 0; + low ^= signmask ^ high; + return qHash(low, seed); + } + return qHash(quint64(key), seed); +} +#if QT_SUPPORTS_INT128 +constexpr size_t qHash(quint128 key, size_t seed = 0) noexcept +{ + return qHash(quint64(key + (key >> 64)), seed); +} +constexpr size_t qHash(qint128 key, size_t seed = 0) noexcept { - return (sizeof(ulong) > sizeof(uint)) - ? (uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed) - : (uint(key & (~0U)) ^ seed); + // Avoid QTBUG-116080: same as above, but with double the sizes and without + // the need for compatibility + quint64 high = quint64(quint128(key) >> 64); + quint64 low = quint64(quint128(key)); + quint64 signmask = qint64(high) >> 63; // all zeroes or all ones + low += signmask ^ high; + return qHash(low, seed); } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(long key, uint seed = 0) noexcept { return qHash(ulong(key), seed); } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(quint64 key, uint seed = 0) noexcept +#endif // QT_SUPPORTS_INT128 +Q_DECL_CONST_FUNCTION inline size_t qHash(float key, size_t seed = 0) noexcept { - return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed; + // ensure -0 gets mapped to 0 + key += 0.0f; + uint k; + memcpy(&k, &key, sizeof(float)); + return QHashPrivate::hash(k, seed); } -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(qint64 key, uint seed = 0) noexcept { return qHash(quint64(key), seed); } -Q_CORE_EXPORT Q_DECL_CONST_FUNCTION uint qHash(float key, uint seed = 0) noexcept; -Q_CORE_EXPORT Q_DECL_CONST_FUNCTION uint qHash(double key, uint seed = 0) noexcept; -#if !defined(Q_OS_DARWIN) || defined(Q_CLANG_QDOC) -Q_CORE_EXPORT Q_DECL_CONST_FUNCTION uint qHash(long double key, uint seed = 0) noexcept; +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION size_t qHash(double key, size_t seed = 0) noexcept; +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION size_t qHash(long double key, size_t seed = 0) noexcept; +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(wchar_t key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(char16_t key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(char32_t key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } +#ifdef __cpp_char8_t +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(char8_t key, size_t seed = 0) noexcept +{ return QHashPrivate::hash(size_t(key), seed); } #endif -Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(const QChar key, uint seed = 0) noexcept { return qHash(key.unicode(), seed); } -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qHash(const QByteArray &key, uint seed = 0) noexcept; -#if QT_STRINGVIEW_LEVEL < 2 -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qHash(const QString &key, uint seed = 0) noexcept; -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qHash(const QStringRef &key, uint seed = 0) noexcept; +template <class T> inline size_t qHash(const T *key, size_t seed = 0) noexcept +{ + return qHash(reinterpret_cast<quintptr>(key), seed); +} +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(std::nullptr_t, size_t seed = 0) noexcept +{ + return seed; +} +template <class Enum, std::enable_if_t<std::is_enum_v<Enum>, bool> = true> +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(Enum e, size_t seed = 0) noexcept +{ return QHashPrivate::hash(qToUnderlying(e), seed); } + +// (some) Qt types +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(const QChar key, size_t seed = 0) noexcept { return qHash(key.unicode(), seed); } + +#if QT_CORE_REMOVED_SINCE(6, 4) +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(const QByteArray &key, size_t seed = 0) noexcept; +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(const QByteArrayView &key, size_t seed = 0) noexcept; +#else +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(QByteArrayView key, size_t seed = 0) noexcept; +inline Q_DECL_PURE_FUNCTION size_t qHash(const QByteArray &key, size_t seed = 0 + QT6_DECL_NEW_OVERLOAD_TAIL) noexcept +{ return qHash(qToByteArrayViewIgnoringNull(key), seed); } #endif -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qHash(QStringView key, uint seed = 0) noexcept; -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qHash(const QBitArray &key, uint seed = 0) noexcept; -Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qHash(QLatin1String key, uint seed = 0) noexcept; + +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(QStringView key, size_t seed = 0) noexcept; +inline Q_DECL_PURE_FUNCTION size_t qHash(const QString &key, size_t seed = 0) noexcept +{ return qHash(QStringView{key}, seed); } +#ifndef QT_BOOTSTRAPPED +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(const QBitArray &key, size_t seed = 0) noexcept; +#endif +Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(QLatin1StringView key, size_t seed = 0) noexcept; +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(QKeyCombination key, size_t seed = 0) noexcept +{ return qHash(key.toCombined(), seed); } Q_CORE_EXPORT Q_DECL_PURE_FUNCTION uint qt_hash(QStringView key, uint chained = 0) noexcept; -Q_DECL_CONST_FUNCTION inline uint qHash(std::nullptr_t, uint seed = 0) noexcept +template <typename Enum> +Q_DECL_CONST_FUNCTION constexpr inline size_t qHash(QFlags<Enum> flags, size_t seed = 0) noexcept +{ return qHash(flags.toInt(), seed); } + +// ### Qt 7: remove this "catch-all" overload logic, and require users +// to provide the two-argument version of qHash. +#if (QT_VERSION < QT_VERSION_CHECK(7, 0, 0)) +// Beware of moving this code from here. It needs to see all the +// declarations of qHash overloads for C++ fundamental types *before* +// its own declaration. +namespace QHashPrivate { +template <typename T, typename = void> +constexpr inline bool HasQHashSingleArgOverload = false; + +template <typename T> +constexpr inline bool HasQHashSingleArgOverload<T, std::enable_if_t< + std::is_convertible_v<decltype(qHash(std::declval<const T &>())), size_t> +>> = true; +} + +template <typename T, std::enable_if_t<QHashPrivate::HasQHashSingleArgOverload<T> && !std::is_enum_v<T>, bool> = true> +size_t qHash(const T &t, size_t seed) noexcept(noexcept(qHash(t))) +{ return qHash(t) ^ seed; } +#endif // < Qt 7 + +namespace QHashPrivate { +#ifdef __cpp_concepts +template <typename Key, typename T> concept HeterogeneouslySearchableWithHelper = + // if Key and T are not the same (member already exists) + !std::is_same_v<Key, T> + // but are comparable amongst each other + && std::equality_comparable_with<Key, T> + // and supports heteregenous hashing + && QHashHeterogeneousSearch<Key, T>::value; +template <typename Key, typename T> concept HeterogeneouslySearchableWith = + HeterogeneouslySearchableWithHelper<q20::remove_cvref_t<Key>, q20::remove_cvref_t<T>>; +#else +template <typename Key, typename T> constexpr bool HeterogeneouslySearchableWith = false; +#endif +} + +template<typename T> +bool qHashEquals(const T &a, const T &b) { - return qHash(reinterpret_cast<quintptr>(nullptr), seed); + return a == b; } -template <class T> inline uint qHash(const T *key, uint seed = 0) noexcept +template <typename T1, typename T2> +std::enable_if_t<QHashPrivate::HeterogeneouslySearchableWith<T1, T2>, bool> +qHashEquals(const T1 &a, const T2 &b) { - return qHash(reinterpret_cast<quintptr>(key), seed); + return a == b; } -template<typename T> inline uint qHash(const T &t, uint seed) - noexcept(noexcept(qHash(t))) -{ return qHash(t) ^ seed; } namespace QtPrivate { -struct QHashCombine { - typedef uint result_type; +struct QHashCombine +{ + typedef size_t result_type; template <typename T> - Q_DECL_CONSTEXPR result_type operator()(uint seed, const T &t) const noexcept(noexcept(qHash(t))) + constexpr result_type operator()(size_t seed, const T &t) const noexcept(noexcept(qHash(t))) // combiner taken from N3876 / boost::hash_combine { return seed ^ (qHash(t) + 0x9e3779b9 + (seed << 6) + (seed >> 2)) ; } }; -struct QHashCombineCommutative { +struct QHashCombineCommutative +{ // QHashCombine is a good hash combiner, but is not commutative, // ie. it depends on the order of the input elements. That is // usually what we want: {0,1,3} should hash differently than // {1,3,0}. Except when it isn't (e.g. for QSet and // QHash). Therefore, provide a commutative combiner, too. - typedef uint result_type; + typedef size_t result_type; template <typename T> - Q_DECL_CONSTEXPR result_type operator()(uint seed, const T &t) const noexcept(noexcept(qHash(t))) + constexpr result_type operator()(size_t seed, const T &t) const noexcept(noexcept(qHash(t))) { return seed + qHash(t); } // don't use xor! }; +template <typename... T> +using QHashMultiReturnType = decltype( + std::declval< std::enable_if_t<(sizeof...(T) > 0)> >(), + (qHash(std::declval<const T &>()), ...), + size_t{} +); + +// workaround for a MSVC ICE, +// https://developercommunity.visualstudio.com/content/problem/996540/internal-compiler-error-on-msvc-1924-when-doing-sf.html +template <typename T> +inline constexpr bool QNothrowHashableHelper_v = noexcept(qHash(std::declval<const T &>())); + +template <typename T, typename Enable = void> +struct QNothrowHashable : std::false_type {}; + +template <typename T> +struct QNothrowHashable<T, std::enable_if_t<QNothrowHashableHelper_v<T>>> : std::true_type {}; + +template <typename T> +constexpr inline bool QNothrowHashable_v = QNothrowHashable<T>::value; + } // namespace QtPrivate +template <typename... T> +constexpr +#ifdef Q_QDOC +size_t +#else +QtPrivate::QHashMultiReturnType<T...> +#endif +qHashMulti(size_t seed, const T &... args) + noexcept(std::conjunction_v<QtPrivate::QNothrowHashable<T>...>) +{ + QtPrivate::QHashCombine hash; + return ((seed = hash(seed, args)), ...), seed; +} + +template <typename... T> +constexpr +#ifdef Q_QDOC +size_t +#else +QtPrivate::QHashMultiReturnType<T...> +#endif +qHashMultiCommutative(size_t seed, const T &... args) + noexcept(std::conjunction_v<QtPrivate::QNothrowHashable<T>...>) +{ + QtPrivate::QHashCombineCommutative hash; + return ((seed = hash(seed, args)), ...), seed; +} + template <typename InputIterator> -inline uint qHashRange(InputIterator first, InputIterator last, uint seed = 0) +inline size_t qHashRange(InputIterator first, InputIterator last, size_t seed = 0) noexcept(noexcept(qHash(*first))) // assume iterator operations don't throw { return std::accumulate(first, last, seed, QtPrivate::QHashCombine()); } template <typename InputIterator> -inline uint qHashRangeCommutative(InputIterator first, InputIterator last, uint seed = 0) +inline size_t qHashRangeCommutative(InputIterator first, InputIterator last, size_t seed = 0) noexcept(noexcept(qHash(*first))) // assume iterator operations don't throw { return std::accumulate(first, last, seed, QtPrivate::QHashCombineCommutative()); } -template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key, uint seed = 0) - noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed))) +namespace QHashPrivate { +template <typename T1, typename T2> static constexpr bool noexceptPairHash() { - uint h1 = qHash(key.first, seed); - uint h2 = qHash(key.second, seed); - return ((h1 << 16) | (h1 >> 16)) ^ h2 ^ seed; + size_t seed = 0; + return noexcept(qHash(std::declval<T1>(), seed)) && noexcept(qHash(std::declval<T2>(), seed)); } +} // QHashPrivate -template <typename T1, typename T2> inline uint qHash(const std::pair<T1, T2> &key, uint seed = 0) - noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed))) +template <typename T1, typename T2> inline size_t qHash(const std::pair<T1, T2> &key, size_t seed) + noexcept(QHashPrivate::noexceptPairHash<T1, T2>()) { - QtPrivate::QHashCombine hash; - seed = hash(seed, key.first); - seed = hash(seed, key.second); - return seed; + return qHashMulti(seed, key.first, key.second); } #define QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH(Class, Arguments) \ @@ -181,15 +376,15 @@ template <typename T1, typename T2> inline uint qHash(const std::pair<T1, T2> &k using argument_type = QT_PREPEND_NAMESPACE(Class); \ using result_type = size_t; \ size_t operator()(Arguments s) const \ - noexcept(noexcept(QT_PREPEND_NAMESPACE(qHash)(s))) \ + noexcept(QT_PREPEND_NAMESPACE( \ + QtPrivate::QNothrowHashable_v)<argument_type>) \ { \ /* this seeds qHash with the result of */ \ /* std::hash applied to an int, to reap */ \ /* any protection against predictable hash */ \ /* values the std implementation may provide */ \ - return QT_PREPEND_NAMESPACE(qHash)(s, \ - QT_PREPEND_NAMESPACE(qHash)( \ - std::hash<int>{}(0))); \ + using QT_PREPEND_NAMESPACE(qHash); \ + return qHash(s, qHash(std::hash<int>{}(0))); \ } \ }; \ } \ @@ -202,11 +397,13 @@ template <typename T1, typename T2> inline uint qHash(const std::pair<T1, T2> &k QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH(Class, argument_type) QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_CREF(QString) -QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_CREF(QStringRef) QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_VALUE(QStringView) -QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_VALUE(QLatin1String) +QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_VALUE(QLatin1StringView) +QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_VALUE(QByteArrayView) QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_CREF(QByteArray) +#ifndef QT_BOOTSTRAPPED QT_SPECIALIZE_STD_HASH_TO_CALL_QHASH_BY_CREF(QBitArray) +#endif QT_END_NAMESPACE |