Improve Hashset,Hashmap, Tuple and Pair

Author: Julian LALU

interface/core/containers/hashmap.h

@@ -124,6 +124,32 @@ namespace hud
                 static_assert(hud::is_nothrow_copy_constructible_v<value_t, u_value_t>, "value_t(const u_value_t&) copy constructor is throwable. hashmap_storage is not designed to allow throwable copy constructible components");
             }
 
+            /**
+             * Constructor that initializes the hashmap_storage with a key and a default value.
+             * @tparam u_key_t Type of the key.
+             * @param key The key to initialize with.
+             */
+            template<typename u_key_t>
+            requires(hud::is_constructible_v<pair_type, const u_key_t &, const value_type &>)
+            constexpr explicit hashmap_storage(const u_key_t &key) noexcept
+                : element_(key, value_type {})
+            {
+                static_assert(hud::is_nothrow_constructible_v<pair_type, const u_key_t &, const value_type &>);
+            }
+
+            /**
+             * Constructor that initializes the hashmap_storage with a key and a default value.
+             * @tparam u_key_t Type of the key.
+             * @param key The key to initialize with.
+             */
+            template<typename u_key_t>
+            requires(hud::is_constructible_v<pair_type, u_key_t, value_type>)
+            constexpr explicit hashmap_storage(u_key_t &&key) noexcept
+                : element_(hud::forward<u_key_t>(key), value_type {})
+            {
+                static_assert(hud::is_nothrow_constructible_v<pair_type, u_key_t, value_type>);
+            }
+
             /**
              * Constructor that initializes the hashmap_storage with a key and a value.
              * @tparam u_key_t Type of the key.
@@ -380,6 +406,13 @@ namespace hud
         {
             return super::add(hud::tag_piecewise_construct, hud::forward<key_tuple_t>(key_tuple), hud::forward<value_tuple_t>(value_tuple));
         }
+
+        template<typename KeyArgs>
+        constexpr value_type &operator[](KeyArgs &&args) noexcept
+        {
+            iterator it = super::add(hud::forward<KeyArgs>(args));
+            return it->value();
+        }
     };
 
     /**

interface/core/containers/pair.h

@@ -515,6 +515,40 @@ namespace hud
         }
     }
 
+    template<typename FirstType, typename SecondType>
+    struct equal<hud::pair<FirstType, SecondType>>
+    {
+        template<typename FirstTypeU, typename SecondTypeU>
+        [[nodiscard]] constexpr bool operator()(const hud::pair<FirstType, SecondType> &lhs, const hud::pair<FirstTypeU, SecondTypeU> &rhs) const noexcept
+        {
+            return lhs == rhs;
+        }
+    };
+
+    template<typename FirstType, typename SecondType>
+    struct hash_32<hud::pair<FirstType, SecondType>>
+    {
+        [[nodiscard]] constexpr u32 operator()(const hud::pair<FirstType, SecondType> &t) const noexcept
+        {
+            hasher_32 hasher;
+            hasher.hash(t.first);
+            hasher.hash(t.second);
+            return hasher.result();
+        }
+    };
+
+    template<typename FirstType, typename SecondType>
+    struct hash_64<hud::pair<FirstType, SecondType>>
+    {
+        [[nodiscard]] constexpr u64 operator()(const hud::pair<FirstType, SecondType> &t) const noexcept
+        {
+            hasher_64 hasher;
+            hasher.hash(t.first);
+            hasher.hash(t.second);
+            return hasher.result();
+        }
+    };
+
 } // namespace hud
 
 #endif // HD_INC_CORE_PAIR_H

interface/core/containers/tuple.h

@@ -582,6 +582,39 @@ namespace hud
                 return tuples_cat_impl_type::concatenate(element_index_seq(), mask_index_seq(), hud::forward<tuple_t>(tuple));
             }
         };
+
+        /**
+         * Hashes all elements of a tuple and combines them into a single hash value.
+         * This is a recursive template that processes one element per call.
+         * @tparam count Number of elements remaining to hash.
+         */
+        template<usize count>
+        struct tuple_hash
+        {
+            /**
+             * Hashes the elements of the given tuple recursively, starting from the first unprocessed element.
+             * @tparam Hasher Type of the hasher used.
+             * @tparam types_t Types of the tuple elements.
+             * @param hasher The hasher instance used to compute the hash.
+             * @param t The tuple whose elements are to be hashed.
+             * @return The final combined hash value.
+             */
+            template<typename Hasher, typename... types_t>
+            [[nodiscard]] constexpr decltype(hud::declval<Hasher>().result()) operator()(Hasher &hasher, [[maybe_unused]] const tuple<types_t...> &t) noexcept
+            {
+                if constexpr (count > 0u)
+                {
+                    constexpr const usize index_to_hash = tuple_size_v<tuple<types_t...>> - count;
+                    hasher.hash(hud::get<index_to_hash>(t));
+                    return tuple_hash<count - 1u>()(hasher, t);
+                }
+                else
+                {
+                    return hasher.result();
+                }
+            }
+        };
+
     } // namespace details
 
     /**
@@ -978,7 +1011,7 @@ namespace hud
     template<typename... types_t, typename... u_types_t>
     static constexpr void swap(tuple<types_t...> &first, tuple<u_types_t...> &second) noexcept
     {
-        details::tuple_swap<sizeof...(types_t)>()(first, second);
+        details::tuple_swap<sizeof...(types_t)> {}(first, second);
     }
 
     /**
@@ -992,7 +1025,7 @@ namespace hud
     template<typename... types_t, typename... u_types_t>
     [[nodiscard]] constexpr bool operator==(const tuple<types_t...> &left, const tuple<u_types_t...> &right) noexcept
     {
-        return details::tuple_equals<sizeof...(types_t)>()(left, right);
+        return details::tuple_equals<sizeof...(types_t)> {}(left, right);
     }
 
     /**
@@ -1019,7 +1052,7 @@ namespace hud
     template<typename... types_t, typename... u_types_t>
     [[nodiscard]] constexpr bool operator<(const tuple<types_t...> &left, const tuple<u_types_t...> &right) noexcept
     {
-        return details::tuple_less<sizeof...(types_t)>()(left, right);
+        return details::tuple_less<sizeof...(types_t)> {}(left, right);
     }
 
     /**
@@ -1096,6 +1129,36 @@ namespace hud
         return tuple_cat_result::concatenate(forward_as_tuple(hud::forward<tuples_t>(args)...));
     }
 
+    template<typename... types_t>
+    struct equal<hud::tuple<types_t...>>
+    {
+        template<typename... u_types_t>
+        [[nodiscard]] constexpr bool operator()(const hud::tuple<types_t...> &lhs, const hud::tuple<u_types_t...> &rhs) const noexcept
+        {
+            return lhs == rhs;
+        }
+    };
+
+    template<typename... types_t>
+    struct hash_32<hud::tuple<types_t...>>
+    {
+        [[nodiscard]] constexpr u32 operator()(const hud::tuple<types_t...> &t) const noexcept
+        {
+            hasher_32 hasher;
+            return details::tuple_hash<sizeof...(types_t)> {}(hasher, t);
+        }
+    };
+
+    template<typename... types_t>
+    struct hash_64<hud::tuple<types_t...>>
+    {
+        [[nodiscard]] constexpr u64 operator()(const hud::tuple<types_t...> &t) const noexcept
+        {
+            hasher_64 hasher;
+            return details::tuple_hash<sizeof...(types_t)> {}(hasher, t);
+        }
+    };
+
 } // namespace hud
 
 namespace std

interface/core/hash.h

@@ -164,6 +164,11 @@ namespace hud
         {
             return hud::hash_32<ansichar *, usize> {}(value, length);
         }
+
+        [[nodiscard]] constexpr u32 operator()(const ansichar *value) const
+        {
+            return hud::hash_32<ansichar *, usize> {}(value, cstring::length(value));
+        }
     };
 
     /** Retrieves the 32 bits hash of a wchar null-terminated string. */
@@ -361,6 +366,11 @@ namespace hud
         {
             return hud::hash_64<ansichar *, usize> {}(value, length);
         }
+
+        [[nodiscard]] constexpr u64 operator()(const ansichar *value) const
+        {
+            return hud::hash_64<ansichar *, usize> {}(value, cstring::length(value));
+        }
     };
 
     /** Retrieves the 64 bits hash of a wchar null-terminated string. */
@@ -444,7 +454,7 @@ namespace hud
 
         /** 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
+        constexpr hasher_32 &hash(type_t &&...values) noexcept
         {
             return (*this)(hud::forward<type_t>(values)...);
         }
@@ -485,7 +495,7 @@ namespace hud
 
         /** 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
+        constexpr hasher_64 &hash(type_t &&...values) noexcept
         {
             return (*this)(hud::forward<type_t>(values)...);
         }

test/CMakeLists.txt

@@ -121,6 +121,7 @@ set( src
 	pair/pair_destructor.cpp
 	pair/pair_misc.cpp
 	pair/pair_swap.cpp
+	pair/pair_hash.cpp
 	shared_pointer/multi_thread/shared_pointer_multi_thread_assignments.cpp
 	shared_pointer/multi_thread/shared_pointer_multi_thread_comparison.cpp
 	shared_pointer/multi_thread/shared_pointer_multi_thread_constructors.cpp
@@ -285,6 +286,7 @@ set( src
 	tuple/tuple_swap.cpp
 	tuple/tuple_element.cpp
 	tuple/tuple_size.cpp
+	tuple/tuple_hash.cpp
 	u128/u128_assign.cpp
 	u128/u128_cast.cpp
 	u128/u128_comparisons.cpp

test/hashmap/hashmap_add.cpp

@@ -5068,7 +5068,7 @@ GTEST_TEST(hashmap, add_by_piecewise_construct_non_bitwise_same_type)
         map.reserve(reserved_size);
 
         static_assert(hud::is_hashable_64_v<key_type, decltype(hud::forward_as_tuple(1, ptr))>);
-        static_assert(hud::is_comparable_with_equal_v<key_type, decltype(hud::forward_as_tuple(2, ptr + 1))>);
+        static_assert(hud::is_comparable_with_equal_v<key_type, decltype(hud::forward_as_tuple(1, ptr))>);
 
         const auto it = map.add(hud::tag_piecewise_construct, hud::forward_as_tuple(1, ptr), hud::forward_as_tuple(2, ptr + 1));
 
@@ -5146,7 +5146,7 @@ GTEST_TEST(hashmap, add_by_piecewise_construct_non_bitwise_different_type)
         map.reserve(reserved_size);
 
         static_assert(hud::is_hashable_64_v<key_type, decltype(hud::forward_as_tuple(i64 {1}, ptr))>);
-        static_assert(hud::is_comparable_with_equal_v<key_type, decltype(hud::forward_as_tuple(u64 {2}, ptr + 1))>);
+        static_assert(hud::is_comparable_with_equal_v<key_type, decltype(hud::forward_as_tuple(i64 {1}, ptr))>);
 
         const auto it = map.add(hud::tag_piecewise_construct, hud::forward_as_tuple(i64 {1}, ptr), hud::forward_as_tuple(u64 {2}, ptr + 1));
 
@@ -5208,4 +5208,56 @@ GTEST_TEST(hashmap, add_by_piecewise_construct_non_bitwise_different_type)
         hud_assert_true(std::get<13>(result));
         hud_assert_true(std::get<14>(result));
     }
-}
+}
+
+GTEST_TEST(hashmap, add_by_piecewise_construct_tuples)
+{
+    using key_type = hud::tuple<i32, u64, hud_test::non_bitwise_type>;
+    using value_type = hud::tuple<i32, u64, hud_test::non_bitwise_type>;
+    using hashmap_type = hud::hashmap<key_type, value_type, hud::hash_64<key_type>, hud::equal<key_type>, hud_test::allocator_watcher<1>>;
+
+    const auto test = []()
+    {
+        constexpr usize reserved_size = 2;
+        i32 ptr[2];
+        hashmap_type map;
+        map.reserve(reserved_size);
+
+        static_assert(hud::is_hashable_64_v<key_type, decltype(hud::forward_as_tuple(1, 2, hud_test::non_bitwise_type {3, ptr}))>);
+        static_assert(hud::is_comparable_with_equal_v<key_type, decltype(hud::forward_as_tuple(1, 2, hud_test::non_bitwise_type {3, ptr}))>);
+
+        const auto it = map.add(hud::tag_piecewise_construct, hud::forward_as_tuple(1, 2, hud_test::non_bitwise_type {3, ptr}), hud::forward_as_tuple(4, 5, hud_test::non_bitwise_type {6, ptr + 1}));
+
+        const key_type expected_key {
+            1,
+            2,
+            hud_test::non_bitwise_type {3, ptr}
+        };
+        const value_type expected_value {
+            4,
+            5,
+            hud_test::non_bitwise_type {6, ptr + 1}
+        };
+        return std::tuple {
+            map.count() == 1,              // 0
+            it->key() == expected_key,     // 1
+            it->value() == expected_value, // 2
+        };
+    };
+
+    // Non constant
+    {
+        const auto result = test();
+        hud_assert_true(std::get<0>(result));
+        hud_assert_true(std::get<1>(result));
+        hud_assert_true(std::get<2>(result));
+    }
+
+    // Constant
+    {
+        constexpr auto result = test();
+        hud_assert_true(std::get<0>(result));
+        hud_assert_true(std::get<1>(result));
+        hud_assert_true(std::get<2>(result));
+    }
+}

test/hashmap/hashmap_indexed_operator.cpp

@@ -1 +1,17 @@
 #include <core/containers/hashmap.h>
+
+GTEST_TEST(hashmap, indexed_operator_trivial_same_type)
+{
+    const auto test = []()
+    {
+        hud::hashmap<usize, usize> map;
+        map[1] = 2;
+        hud::hashmap<const char *, const char *> map2;
+        map2["key"] = "value";
+
+        return std::tuple {
+            map.find(1)->value() = 2,
+            map2.find("key")->value() = "value",
+        };
+    };
+}

test/pair/pair_hash.cpp

@@ -0,0 +1,37 @@
+#include <core/containers/pair.h>
+#include <core/hash.h>
+
+GTEST_TEST(pair, hash_pair)
+{
+    const auto test = []()
+    {
+        using PairType = hud::pair<i32, hud_test::non_bitwise_type>;
+        u32 result_hash32 = hud::hash_32<PairType> {}(PairType {1, 2});
+        hud::hasher_32 hasher32;
+        hasher32.hash(i32 {1});
+        hasher32.hash(hud_test::non_bitwise_type {2});
+
+        u64 result_hash64 = hud::hash_64<PairType> {}(PairType {1, 2});
+        hud::hasher_64 hasher64;
+        hasher64.hash(i32 {1});
+        hasher64.hash(hud_test::non_bitwise_type {2});
+        return std::tuple {
+            result_hash32 == hasher32.result(),
+            result_hash64 == hasher64.result()
+        };
+    };
+
+    // Non constant
+    {
+        const auto result = test();
+        hud_assert_true(std::get<0>(result));
+        hud_assert_true(std::get<1>(result));
+    }
+
+    // Constant
+    {
+        constexpr auto result = test();
+        hud_assert_true(std::get<0>(result));
+        hud_assert_true(std::get<1>(result));
+    }
+}