Add hasher_32 and hasher_64

Author: Julian LALU

interface/core/containers/hashmap.h

@@ -13,13 +13,14 @@ namespace hud
     {
         template<typename key_t>
         struct default_hasher
+            : hud::hasher_64
         {
             using key_type = key_t;
 
-            [[nodiscard]] u64 operator()(const key_type &key) const noexcept
-            {
-                return hud::hash_64(key);
-            }
+            // [[nodiscard]] u64 operator()(const key_type &key) const noexcept
+            // {
+            //     return hud::hash_64(key);
+            // }
         };
 
         template<typename key_t> struct default_equal

interface/core/containers/shared_pointer.h

@@ -1418,15 +1418,15 @@ namespace hud
     HD_FORCEINLINE u32 hash_32(const shared_pointer<type_t, thread_safety> &ptr) noexcept
     {
         // Simply hash the pointer
-        return hash_32(ptr.pointer());
+        return hash_32(static_cast<const void *>(ptr.pointer()));
     }
 
     /** Specialization of the hash function for shared_pointer */
     template<typename type_t, thread_safety_e thread_safety>
     HD_FORCEINLINE u64 hash_64(const shared_pointer<type_t, thread_safety> &ptr) noexcept
     {
         // Simply hash the pointer
-        return hash_64(ptr.pointer());
+        return hash_64(static_cast<const void *>(ptr.pointer()));
     }
 
 } // namespace hud

interface/core/containers/unique_pointer.h

@@ -1058,14 +1058,14 @@ namespace hud
     template<typename type_t>
     constexpr u32 hash_32(const unique_pointer<type_t> &ptr) noexcept
     {
-        return hud::hash_32(ptr.pointer());
+        return hud::hash_32(static_cast<const void *>(ptr.pointer()));
     }
 
     /** Specialization of the hash function for unique_pointer */
     template<typename type_t>
     constexpr u64 hash_64(const unique_pointer<type_t> &ptr) noexcept
     {
-        return hud::hash_64(ptr.pointer());
+        return hud::hash_64(static_cast<const void *>(ptr.pointer()));
     }
 
 } // namespace hud

interface/core/hash.h

@@ -6,6 +6,7 @@
 #include "traits/is_integral.h"
 #include "hash/city_hash.h"
 #include "templates/bit_cast.h"
+#include <core/cstring.h>
 
 namespace hud
 {
@@ -80,15 +81,43 @@ namespace hud
     }
 
     /** Retrieves the 32 bits hash of a ansichar null-terminated string. */
-    [[nodiscard]] static inline u32 hash_32(const ansichar *value, usize length) noexcept
+    [[nodiscard]] static constexpr u32 hash_32(const ansichar *value, usize length) noexcept
     {
         return hud::hash_algorithm::city_hash::hash_32(value, length);
     }
 
+    /** Retrieves the 32 bits hash of a ansichar null-terminated string. */
+    [[nodiscard]] static constexpr u32 hash_32(const ansichar *const value) noexcept
+    {
+        return hash_32(value, hud::cstring::length(value));
+    }
+
     /** Retrieves the 32 bits hash of a wchar null-terminated string. */
-    [[nodiscard]] static inline u32 hash_32(const wchar *value, usize length) noexcept
+    [[nodiscard]] static constexpr u32 hash_32(const wchar *value, usize length) noexcept
     {
-        return hud::hash_algorithm::city_hash::hash_32(reinterpret_cast<const ansichar *>(value), length * sizeof(wchar));
+        struct A
+        {
+            union
+            {
+                const ansichar *a_;
+                const wchar *w_;
+            };
+
+            constexpr A(const wchar *w)
+                : w_(w)
+            {
+            }
+        };
+
+        A a(value);
+        a.w_;
+        return hud::hash_algorithm::city_hash::hash_32(a.a_, length * sizeof(wchar));
+    }
+
+    /** Retrieves the 32 bits hash of a ansichar null-terminated string. */
+    [[nodiscard]] static constexpr u32 hash_32(const wchar *const value) noexcept
+    {
+        return hash_32(value, hud::cstring::length(value));
     }
 
     /** Retrieves the 32 bits hash of an enumeration. */
@@ -100,8 +129,7 @@ namespace hud
     }
 
     /** Retrieves the 32 bits hash of a pointer of a type type_t. */
-    template<typename type_t>
-    [[nodiscard]] static u32 hash_32(type_t *const pointer) noexcept
+    [[nodiscard]] static inline u32 hash_32(const void *const pointer) noexcept
     {
         const uptr ptr = reinterpret_cast<uptr>(pointer);
         if constexpr (sizeof(uptr) == 4)
@@ -184,17 +212,29 @@ namespace hud
     }
 
     /** Retrieves the 64 bits hash of a ansichar null-terminated string. */
-    [[nodiscard]] static inline u64 hash_64(const ansichar *value, usize length) noexcept
+    [[nodiscard]] static constexpr u64 hash_64(const ansichar *value, usize length) noexcept
     {
         return hud::hash_algorithm::city_hash::hash_64(value, length);
     }
 
+    /** Retrieves the 32 bits hash of a ansichar null-terminated string. */
+    [[nodiscard]] static constexpr u32 hash_64(const ansichar *const value) noexcept
+    {
+        return hash_64(value, hud::cstring::length(value));
+    }
+
     /** Retrieves the 64 bits hash of a wchar null-terminated string. */
     [[nodiscard]] static inline u64 hash_64(const wchar *value, usize length) noexcept
     {
         return hud::hash_algorithm::city_hash::hash_64(reinterpret_cast<const ansichar *>(value), length * sizeof(wchar));
     }
 
+    /** Retrieves the 32 bits hash of a ansichar null-terminated string. */
+    [[nodiscard]] static inline u64 hash_64(const wchar *const value) noexcept
+    {
+        return hash_64(value, hud::cstring::length(value));
+    }
+
     /** Retrieves the 64 bits hash of an enumeration. */
     template<typename type_t>
     requires(is_enum_v<type_t>)
@@ -204,8 +244,7 @@ namespace hud
     }
 
     /** Retrieves the 64 bits hash of a pointer of a type type_t. */
-    template<typename type_t>
-    [[nodiscard]] static u64 hash_64(type_t *const pointer) noexcept
+    [[nodiscard]] static inline u64 hash_64(const void *const pointer) noexcept
     {
         const uptr ptr = reinterpret_cast<uptr>(pointer);
         if constexpr (sizeof(uptr) == 4)
@@ -224,18 +263,30 @@ namespace hud
         return hud::hash_algorithm::city_hash::combine_64(a, b);
     }
 
-    struct Hasher32
+    struct hasher_32
     {
-        template<typename T>
-        [[nodiscard]] constexpr u32 operator()(const T &value) noexcept
+        template<typename... type_t>
+        [[nodiscard]] constexpr u32 operator()(type_t &&...values) noexcept
         {
-            state_ = hud::combine_32(state_, hud::hash_32(value));
+            state_ = hud::combine_32(state_, hud::hash_32(hud::forward<type_t>(values)...));
             return state_;
         }
 
         u32 state_ {0}; // Default is 0, but can be a seed
     };
 
+    struct hasher_64
+    {
+        template<typename... type_t>
+        [[nodiscard]] constexpr u64 operator()(type_t &&...values) noexcept
+        {
+            state_ = hud::combine_64(state_, hud::hash_64(hud::forward<type_t>(values)...));
+            return state_;
+        }
+
+        u64 state_ {0}; // Default is 0, but can be a seed
+    };
+
 } // namespace hud
 
 #endif // HD_INC_CORE_HASH_H

interface/core/os_common/cstring.h

@@ -13,8 +13,9 @@ namespace hud::os::common
 
     struct cstring
     {
-        static constexpr u32 RSIZE_MAX_STR {4UL << 10};         // 4KB
-        static constexpr usize RSIZE_MAX {hud::usize_max >> 1}; // Largest acceptable size for bounds-checked functions
+        static constexpr u32 RSIZE_MAX_STR {4UL << 10}; // 4KB
+
+        // static constexpr u64 RSIZE_MAX {hud::usize_max >> 1}; // Largest acceptable size for bounds-checked functions
 
         /**
          * Test whether null-terminated string contains only pure ansi characters.
@@ -492,9 +493,24 @@ namespace hud::os::common
          * @param string Null-terminated string
          * @return Length of the string
          */
-        static HD_FORCEINLINE usize length(const wchar *string) noexcept
+        [[nodiscard]] static constexpr usize length(const wchar *string) noexcept
         {
-            return wcslen(string);
+            if (hud::is_constant_evaluated())
+            {
+                // LCOV_EXCL_START
+                usize string_length = 0;
+                while (*string != '\0')
+                {
+                    string_length++;
+                    string++;
+                }
+                return string_length;
+                // LCOV_EXCL_STOP
+            }
+            else
+            {
+                return wcslen(string);
+            }
         }
 
         /**

test/hash/city_hash.cpp

@@ -39,6 +39,10 @@ GTEST_TEST(cityhash, hash32)
     // Test with the lipsum
     const u32 hash = hud::hash_algorithm::city_hash::hash_32(lipsum, hud::cstring::length(lipsum));
     hud_assert_eq(hash, CityHash32(lipsum, hud::cstring::length(lipsum)));
+
+    // Test with "key"
+    constexpr const usize len = hud::cstring::length("key");
+    hud_assert_eq(hud::hash_algorithm::city_hash::hash_32("key", len), 0x1096A99Du);
 }
 
 GTEST_TEST(cityhash, hash32_is_usable_in_constexpr)
@@ -67,9 +71,13 @@ GTEST_TEST(cityhash, hash64)
         hud_assert_eq(hud_test::city_hash_64_result[i], out);
     }
 
+    // Test with the lipsum
+    const u64 hash = hud::hash_algorithm::city_hash::hash_64(lipsum, hud::cstring::length(lipsum));
+    hud_assert_eq(hash, CityHash64(lipsum, hud::cstring::length(lipsum)));
+
+    // Test with "key"
     constexpr const usize len = hud::cstring::length("key");
     hud_assert_eq(hud::hash_algorithm::city_hash::hash_64("key", len), 0x0BB7560E11262CDB);
-    hud_assert_eq(hud::hash_algorithm::city_hash::hash_64((const ansichar *)&len, sizeof(len)), 0x64C856FF72C54198u);
 }
 
 GTEST_TEST(cityhash, hash64_is_usable_in_constexpr)
@@ -79,6 +87,7 @@ GTEST_TEST(cityhash, hash64_is_usable_in_constexpr)
     hud_assert_eq(CityHash64(nullptr, 0), hash_nullptr);
 
     constexpr u64 hash_lipsum = hud::hash_algorithm::city_hash::hash_64(lipsum, hud::cstring::length(lipsum));
+
     // Test with the lipsum
     hud_assert_eq(hash_lipsum, CityHash64(lipsum, hud::cstring::length(lipsum)));
 }
@@ -102,7 +111,19 @@ GTEST_TEST(cityhash, hash128)
     }
 }
 
-GTEST_TEST(cityhash, combine)
+GTEST_TEST(cityhash, combine_32)
+{
+    // This result come from abseil with modification of the hash combine to use the Hash128to64 to combine 2 32 bits hash
+    constexpr const usize len = hud::cstring::length("key");
+    u32 hash = hud::hash_algorithm::city_hash::hash_32("key", len);
+    u32 combined = hud::hash_algorithm::city_hash::combine_32(0, hash);
+    hud_assert_eq(combined, 0x105695BEu);
+
+    u32 hash_2 = hud::hash_algorithm::city_hash::hash_32((const ansichar *)&len, sizeof(len));
+    hud_assert_eq(hud::hash_algorithm::city_hash::combine_32(combined, hash_2), 0xE638A9DBu);
+}
+
+GTEST_TEST(cityhash, combine_64)
 {
     // This result come from abseil with modification of the hash combine to use the Hash128to64 to combine 2 64 bits hash
     constexpr const usize len = hud::cstring::length("key");

test/hash/hash_32.cpp

@@ -128,5 +128,13 @@ GTEST_TEST(hash_32, hash_enumeration_are_usable_in_constexpr)
 GTEST_TEST(hash_32, hash_can_hash_pointers)
 {
     const u32 *ptr = nullptr;
-    hud_assert_eq(hud::hash_32(ptr), reinterpret_cast<uptr>(ptr));
+    hud_assert_eq(hud::hash_32(static_cast<const void *>(ptr)), reinterpret_cast<uptr>(ptr));
 }
+
+GTEST_TEST(hash_32, hasher32)
+{
+    constexpr const usize len = hud::cstring::length("key");
+    hud::hasher_32 hasher;
+    hud_assert_eq(hasher("key", len), 0x105695BEu);
+    hud_assert_eq(hasher((const ansichar *)&len, sizeof(len)), 0xE638A9DBu);
+}

test/hash/hash_64.cpp

@@ -82,6 +82,31 @@ GTEST_TEST(hash_64, hash_can_hash_c_string)
     }
 }
 
+GTEST_TEST(hash_64, hash_can_hash_c_string_are_usable_in_constexpr)
+{
+    static constexpr const ansichar txt[] = "abcdefghijklmnopqrstuvwxyz";
+    constexpr u64 hash_a = hud::hash_64(txt, hud::cstring::length(txt));
+    hud_assert_eq(hash_a, 0x5EAD741CE7AC31BDu);
+
+    // Not Possible, wchar* cannot be cast to ansichar at compile time
+    //
+    // static constexpr const wchar *wtxt = L"abcdefghijklmnopqrstuvwxyz";
+    // if constexpr (sizeof(wchar) == 2)
+    // {
+    //     constexpr u64 hash_w = hud::hash_64(wtxt, hud::cstring::length(wtxt));
+    //     hud_assert_eq(hash_w, 0xE66EDE359E692EBBu);
+    // }
+    // else if constexpr (sizeof(wchar) == 4)
+    // {
+    //     constexpr u64 hash_w = hud::hash_64(wtxt, hud::cstring::length(wtxt));
+    //     hud_assert_eq(hash_w, 0xF09AD8D8223EE63Bu);
+    // }
+    // else
+    // {
+    //     FAIL();
+    // }
+}
+
 GTEST_TEST(hash_64, hash_can_hash_enumeration)
 {
     enum class E : u32
@@ -127,5 +152,13 @@ GTEST_TEST(hash_64, hash_enumeration_are_usable_in_constexpr)
 GTEST_TEST(hash_64, hash_can_hash_pointers)
 {
     const u64 *ptr = nullptr;
-    hud_assert_eq(hud::hash_64(ptr), reinterpret_cast<uptr>(ptr));
+    hud_assert_eq(hud::hash_64(static_cast<const void *>(ptr)), reinterpret_cast<uptr>(ptr));
 }
+
+GTEST_TEST(hash_64, hasher64)
+{
+    constexpr const usize len = hud::cstring::length("key");
+    hud::hasher_64 hasher;
+    hud_assert_eq(hasher("key", len), 0xCEAAB8E77B74C2E7u);
+    hud_assert_eq(hasher((const ansichar *)&len, sizeof(len)), 0x746D68F6EB969EB7u);
+}

test/hashmap/hashmap_insert.cpp

@@ -4,8 +4,5 @@
 GTEST_TEST(hashmap, insert)
 {
     hud::hashmap<const char *, i64> map;
-    constexpr const usize len = hud::cstring::length("key");
-
-    u64 hash = hud::combine_64(hud::combine_64(0, hud::hash_64("key", len)), hud::hash_64((const char *)&len, sizeof(usize)));
     auto res = map.insert("key", 1);
 }

test/shared_pointer/multi_thread/shared_pointer_multi_thread_misc.cpp

@@ -564,7 +564,7 @@ GTEST_TEST(shared_pointer_safe, hash_32)
     const auto test = []()
     {
         hud::shared_pointer<i32, hud::thread_safety_e::safe> ptr(new i32(123));
-        return hud::hash_32(ptr) == hud::hash_32(ptr.pointer());
+        return hud::hash_32(ptr) == hud::hash_32(static_cast<const void *>(ptr.pointer()));
     };
 
     hud_assert_true(test());
@@ -576,7 +576,7 @@ GTEST_TEST(shared_pointer_safe, hash_64)
     const auto test = []()
     {
         hud::shared_pointer<i32, hud::thread_safety_e::safe> ptr(new i32(123));
-        return hud::hash_64(ptr) == hud::hash_64(ptr.pointer());
+        return hud::hash_64(ptr) == hud::hash_64(static_cast<const void *>(ptr.pointer()));
     };
 
     hud_assert_true(test());