Improve hashers

Author: Julian LALU

interface/core/hash.h

@@ -93,29 +93,13 @@ namespace hud
     }
 
     /** Retrieves the 32 bits hash of a wchar null-terminated string. */
-    [[nodiscard]] static constexpr u32 hash_32(const wchar *value, usize length) noexcept
+    [[nodiscard]] static inline u32 hash_32(const wchar *value, usize length) noexcept
     {
-        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));
+        return hud::hash_algorithm::city_hash::hash_32(reinterpret_cast<const ansichar *>(value), 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
+    [[nodiscard]] static inline u32 hash_32(const wchar *const value) noexcept
     {
         return hash_32(value, hud::cstring::length(value));
     }
@@ -218,7 +202,7 @@ namespace hud
     }
 
     /** Retrieves the 32 bits hash of a ansichar null-terminated string. */
-    [[nodiscard]] static constexpr u32 hash_64(const ansichar *const value) noexcept
+    [[nodiscard]] static constexpr u64 hash_64(const ansichar *const value) noexcept
     {
         return hash_64(value, hud::cstring::length(value));
     }
@@ -263,27 +247,73 @@ namespace hud
         return hud::hash_algorithm::city_hash::combine_64(a, b);
     }
 
-    struct hasher_32
+    /**
+     * A 32 bit hasher class used for hashing an arbitrary stream of bytes
+     * Instances of `hasher_32` usually represent state that is changed while hashing data.
+     * `hasher_32` provides a fairly basic interface for retrieving the generated hash.
+     * `hasher_32` used all functions in `hud` namespace like `hud::hash_32(const u32 value)`, `hud::hash_32(const ansichar *const value)` or `hud::combine_32(u64 a, u64 b)`.
+     *  If you want to hash a user defined type, add your `hud::hash_my_type(my_type& t)` function and just call `hasher_32::operator()`
+     */
+    class hasher_32
     {
+    public:
+        /** Hash the value and combine the value with the current hasher value. */
         template<typename... type_t>
-        [[nodiscard]] constexpr u32 operator()(type_t &&...values) noexcept
+        [[nodiscard]] constexpr hasher_32 &operator()(type_t &&...values) noexcept
         {
             state_ = hud::combine_32(state_, hud::hash_32(hud::forward<type_t>(values)...));
+            return *this;
+        }
+
+        /** Retrieves the value of the `hasher_32`. */
+        [[nodiscard]] operator u32() const noexcept
+        {
             return state_;
         }
 
+        /** Hash the value and combine the value with the current hasher value. */
+        template<typename... type_t>
+        [[nodiscard]] constexpr hasher_32 &hash(type_t &&...values) noexcept
+        {
+            return (*this)(hud::forward<type_t>(values)...);
+        }
+
+    private:
         u32 state_ {0}; // Default is 0, but can be a seed
     };
 
+    /**
+     * A 64 bit hasher class used for hashing an arbitrary stream of bytes
+     * Instances of `hasher_64` usually represent state that is changed while hashing data.
+     * `hasher_64` provides a fairly basic interface for retrieving the generated hash.
+     * `hasher_64` used all functions in `hud` namespace like `hud::hash_64(const u32 value)`, `hud::hash_64(const ansichar *const value)` or `hud::combine_64(u64 a, u64 b)`.
+     *  If you want to hash a user defined type, add your `hud::hash_my_type(my_type& t)` function and just call `hasher_64::operator()`
+     */
     struct hasher_64
     {
+    public:
+        /** Hash the value and combine the value with the current hasher value. */
         template<typename... type_t>
-        [[nodiscard]] constexpr u64 operator()(type_t &&...values) noexcept
+        [[nodiscard]] constexpr hasher_64 &operator()(type_t &&...values) noexcept
         {
             state_ = hud::combine_64(state_, hud::hash_64(hud::forward<type_t>(values)...));
+            return *this;
+        }
+
+        /** Retrieves the value of the `hasher_64`. */
+        [[nodiscard]] operator u64() const noexcept
+        {
             return state_;
         }
 
+        /** Hash the value and combine the value with the current hasher value. */
+        template<typename... type_t>
+        [[nodiscard]] constexpr hasher_64 &hash(type_t &&...values) noexcept
+        {
+            return (*this)(hud::forward<type_t>(values)...);
+        }
+
+    private:
         u64 state_ {0}; // Default is 0, but can be a seed
     };
 

test/hash/hash_32.cpp

@@ -137,4 +137,8 @@ GTEST_TEST(hash_32, hasher32)
     hud::hasher_32 hasher;
     hud_assert_eq(hasher("key", len), 0x105695BEu);
     hud_assert_eq(hasher((const ansichar *)&len, sizeof(len)), 0xE638A9DBu);
+
+    // Test that hasher can be called redundancy
+    u32 value = hud::hasher_32 {}("key").hash((const ansichar *)&len, sizeof(len));
+    hud_assert_eq(value, 0xE638A9DBu);
 }

test/hash/hash_64.cpp

@@ -161,4 +161,8 @@ GTEST_TEST(hash_64, hasher64)
     hud::hasher_64 hasher;
     hud_assert_eq(hasher("key", len), 0xCEAAB8E77B74C2E7u);
     hud_assert_eq(hasher((const ansichar *)&len, sizeof(len)), 0x746D68F6EB969EB7u);
+
+    // Test that hasher can be called redundancy
+    u64 value = hud::hasher_64 {}("key").hash((const ansichar *)&len, sizeof(len));
+    hud_assert_eq(value, 0x746D68F6EB969EB7u);
 }