Avoid redundant hashing

The return type of `std::hash()` is larger (or equal) than what
`qHash()` requires so we can omit hashing it again.

src/base/bittorrent/infohash.cpp

@@ -96,7 +96,7 @@ std::size_t BitTorrent::qHash(const BitTorrent::TorrentID &key, const std::size_
 uint BitTorrent::qHash(const BitTorrent::TorrentID &key, const uint seed)
 #endif
 {
-    return ::qHash(std::hash<TorrentID::UnderlyingType>()(key), seed);
+    return ::qHash(static_cast<TorrentID::BaseType>(key), seed);
 }
 
 bool BitTorrent::operator==(const BitTorrent::InfoHash &left, const BitTorrent::InfoHash &right)

src/base/bittorrent/ltqhash.h

@@ -28,28 +28,24 @@
 
 #pragma once
 
+#include <QtGlobal>
+
+#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 #include <functional>
 
 #include <libtorrent/units.hpp>
 
-#include <QtGlobal>
 #include <QHash>
 
-// From https://doc.qt.io/qt-6/qhash.html#the-hashing-function:
-// A hashing function for a key type K may be provided in two different ways.
-// The first way is by having an overload of qHash() in K's namespace.
 namespace libtorrent
 {
     namespace aux
     {
         template <typename T, typename Tag>
-#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
-        std::size_t qHash(const strong_typedef<T, Tag> &key, const std::size_t seed = 0)
-#else
         uint qHash(const strong_typedef<T, Tag> &key, const uint seed = 0)
-#endif
         {
             return ::qHash((std::hash<strong_typedef<T, Tag>> {})(key), seed);
         }
     }
 }
+#endif

src/base/digest32.h

@@ -131,12 +131,16 @@ bool operator<(const Digest32<N> &left, const Digest32<N> &right)
             < static_cast<typename Digest32<N>::UnderlyingType>(right);
 }
 
-template <int N>
 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+template <int N>
 std::size_t qHash(const Digest32<N> &key, const std::size_t seed = 0)
+{
+    return ::qHash(static_cast<typename Digest32<N>::UnderlyingType>(key), seed);
+}
 #else
+template <int N>
 uint qHash(const Digest32<N> &key, const uint seed = 0)
-#endif
 {
-    return ::qHash(std::hash<typename Digest32<N>::UnderlyingType>()(key), seed);
+    return static_cast<uint>((std::hash<typename Digest32<N>::UnderlyingType> {})(key)) ^ seed;
 }
+#endif