qt 6.5.1 original

tests/benchmarks/corelib/tools/qhash/outofline.cpp

@@ -0,0 +1,56 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "tst_bench_qhash.h"
+
+QT_BEGIN_NAMESPACE
+
+size_t qHash(const Qt4String &str)
+{
+    qsizetype n = str.size();
+    const QChar *p = str.unicode();
+    uint h = 0;
+
+    while (n--) {
+        h = (h << 4) + (*p++).unicode();
+        h ^= (h & 0xf0000000) >> 23;
+        h &= 0x0fffffff;
+    }
+    return h;
+}
+
+size_t qHash(const Qt50String &key, size_t seed)
+{
+    const QChar *p = key.unicode();
+    qsizetype len = key.size();
+    size_t h = seed;
+    for (int i = 0; i < len; ++i)
+        h = 31 * h + p[i].unicode();
+    return h;
+}
+
+// The Java's hashing algorithm for strings is a variation of D. J. Bernstein
+// hashing algorithm appeared here http://cr.yp.to/cdb/cdb.txt
+// and informally known as DJB33XX - DJB's 33 Times Xor.
+// Java uses DJB31XA, that is, 31 Times Add.
+// The original algorithm was a loop around  "(h << 5) + h ^ c",
+// which is indeed "h * 33 ^ c"; it was then changed to
+// "(h << 5) - h ^ c", so "h * 31 ^ c", and the XOR changed to a sum:
+// "(h << 5) - h + c", which can save some assembly instructions.
+// Still, we can avoid writing the multiplication as "(h << 5) - h"
+// -- the compiler will turn it into a shift and an addition anyway
+// (for instance, gcc 4.4 does that even at -O0).
+size_t qHash(const JavaString &str)
+{
+    const auto *p = reinterpret_cast<const char16_t *>(str.constData());
+    const qsizetype len = str.size();
+
+    uint h = 0;
+
+    for (int i = 0; i < len; ++i)
+        h = 31 * h + p[i];
+
+    return h;
+}
+
+QT_END_NAMESPACE