Improve Hashset

Author: Julian LALU

interface/core/containers/hashmap.h

@@ -154,6 +154,19 @@ namespace hud
                 static_assert(hud::is_nothrow_constructible_v<pair_type, u_key_t, u_value_t>);
             }
 
+            /**
+             * Constructor that initializes the hashmap_storage with a key and a value.
+             * @tparam u_key_t Type of the key.
+             * @tparam u_value_t Type of the value.
+             * @param key The key to initialize with.
+             * @param value The value to initialize with.
+             */
+            template<typename key_tuple_t, typename value_tuple_t>
+            constexpr explicit hashmap_storage(hud::tag_piecewise_construct_t, key_tuple_t &&key_tuple, value_tuple_t &&value_tuple) noexcept
+                : element_(hud::tag_piecewise_construct, hud::forward<key_tuple_t>(key_tuple), hud::forward<value_tuple_t>(value_tuple))
+            {
+            }
+
             /**
              * Copy assign.
              * Does not accept throwable copy constructible components.
@@ -249,7 +262,7 @@ namespace hud
         using value_type = typename storage_type::value_type;
 
         /** Inherit constructors and methods from the base class. */
-        using super::add;
+        // using super::add;
         using super::reserve;
         using super::super;
         using typename super::allocator_type;
@@ -327,7 +340,7 @@ namespace hud
         template<typename u_key_t = key_t, typename u_value_t = value_t>
         constexpr iterator add(hud::pair<u_key_t, u_value_t> &&pair) noexcept
         {
-            return super::add(hud::get<0>(hud::forward<hud::pair<u_key_t, u_value_t>>(pair)), hud::get<1>(hud::forward<hud::pair<u_key_t, u_value_t>>(pair)));
+            return super::add(hud::forward<u_key_t &&>(pair.first), hud::forward<u_value_t &&>(pair.second));
         }
 
         /**
@@ -336,17 +349,17 @@ namespace hud
          * @param args List of arguments pass to `value_type` constructor after the `key` itself
          * @return Iterator to the `value`
          */
-
-        constexpr iterator add(key_type &&key, value_type &&value) noexcept
-        requires(hud::is_constructible_v<storage_type, key_type, value_type>)
+        template<typename u_key_t = key_t, typename u_value_t = value_t>
+        constexpr iterator add(u_key_t &&key, u_value_t &&value) noexcept
+        requires(hud::is_constructible_v<storage_type, u_key_t, u_value_t>)
         {
-            return super::add(hud::forward<key_type>(key), hud::forward<key_type>(value));
+            return super::add(hud::forward<u_key_t>(key), hud::forward<u_value_t>(value));
         }
 
         template<typename key_tuple_t, typename value_tuple_t>
-        constexpr iterator add(hud::tag_piecewise_construct_t, key_tuple_t key_tuple, value_tuple_t value_tuple) noexcept
+        constexpr iterator add(hud::tag_piecewise_construct_t, key_tuple_t &&key_tuple, value_tuple_t &&value_tuple) noexcept
         {
-            // return super::add(hud::tag_piecewise_construct_t, key_tuple, value_tuple);
+            return super::add(hud::tag_piecewise_construct, hud::forward<key_tuple_t>(key_tuple), hud::forward<value_tuple_t>(value_tuple));
         }
     };
 

interface/core/containers/hashset.h

@@ -1162,20 +1162,39 @@ namespace hud
              * @param args The arguments forwarded to the `slot_type` constructor after the key.
              * @return An iterator to the inserted or existing value.
              */
-            // template<typename key_tuple_t, typename value_tuple_t>
-            // requires(hud::is_constructible_v<slot_type, key_type, args_t...>)
-            // constexpr iterator add(hud::tag_piecewise_construct_t, key_tuple_t key_tuple, value_tuple_t value_tuple) noexcept
-            // {
-            //     hud::pair<usize, bool> res {find_or_insert_no_construct(key)};
-            //     slot_type *slot_ptr {slot_ptr_ + res.first};
-            //     if (res.second)
-            //     {
-            //         hud::memory::construct_object_at(slot_ptr, hud::move(key), hud::forward<args_t>(args)...);
-            //     }
-            //     return {control_ptr_ + res.first, slot_ptr};
-            // }
+            template<typename key_tuple_t, typename value_tuple_t>
+            requires(hud::is_hashable_64_v<key_type, key_tuple_t> && hud::is_comparable_with_equal_v<key_type, key_tuple_t>)
+            constexpr iterator add(hud::tag_piecewise_construct_t, key_tuple_t &&key_tuple, value_tuple_t &&value_tuple) noexcept
+            {
+                hud::pair<usize, bool> res = find_or_insert_no_construct(hud::forward<key_tuple_t>(key_tuple));
+                slot_type *slot_ptr {slot_ptr_ + res.first};
+                if (res.second)
+                {
+                    hud::memory::construct_object_at(slot_ptr, hud::tag_piecewise_construct, hud::forward<key_tuple_t>(key_tuple), hud::forward<value_tuple_t>(value_tuple));
+                }
+                return {control_ptr_ + res.first, slot_ptr};
+            }
+
+            template<typename key_tuple_t, typename value_tuple_t>
+            constexpr iterator add(hud::tag_piecewise_construct_t, key_tuple_t &&key_tuple, value_tuple_t &&value_tuple) noexcept
+            {
+                return add(hud::tag_piecewise_construct, hud::forward<key_tuple_t>(key_tuple), hud::forward<value_tuple_t>(value_tuple), hud::make_index_sequence<hud::tuple_size_v<key_tuple_t>> {}, hud::make_index_sequence<hud::tuple_size_v<value_tuple_t>> {});
+            }
 
         private:
+            template<typename key_tuple_t, usize... indices_key, typename value_tuple_t, usize... indices_value>
+            constexpr iterator add(hud::tag_piecewise_construct_t, key_tuple_t &&key_tuple, value_tuple_t &&value_tuple, hud::index_sequence<indices_key...>, hud::index_sequence<indices_value...>) noexcept
+            {
+                key_type key(hud::get<indices_key>(key_tuple)...);
+                hud::pair<usize, bool> res = find_or_insert_no_construct(key);
+                slot_type *slot_ptr {slot_ptr_ + res.first};
+                if (res.second)
+                {
+                    hud::memory::construct_object_at(slot_ptr, hud::tag_piecewise_construct, hud::forward<key_tuple_t>(key_tuple), hud::forward<value_tuple_t>(value_tuple));
+                }
+                return {control_ptr_ + res.first, slot_ptr};
+            }
+
             template<typename K>
             [[nodiscard]]
             constexpr iterator find_impl(K &&key) noexcept

interface/core/containers/pair.h

@@ -279,16 +279,16 @@ namespace hud
          * Constructs a `pair` from two tuples by unpacking their elements.
          * @tparam tuple_first Type of the first tuple.
          * @tparam tuple_second Type of the second tuple.
-         * @tparam indexes_first Index sequence for elements to extract from the first tuple.
-         * @tparam indexes_second Index sequence for elements to extract from the second tuple.
+         * @tparam indicies_first Index sequence for elements to extract from the first tuple.
+         * @tparam indicies_second Index sequence for elements to extract from the second tuple.
          * @param first_tuple Reference to the first tuple to move from.
          * @param second_tuple Reference to the second tuple to move from.
          * @param ... Index sequences used to unpack the tuple elements.
          */
-        template<typename tuple_first, typename tuple_second, usize... indexes_first, usize... indexes_second>
-        constexpr pair(tuple_first &first_tuple, tuple_second &second_tuple, hud::index_sequence<indexes_first...>, hud::index_sequence<indexes_second...>) noexcept
-            : first(hud::get<indexes_first>(hud::move(first_tuple))...)
-            , second(hud::get<indexes_second>(hud::move(second_tuple))...)
+        template<typename tuple_first, typename tuple_second, usize... indicies_first, usize... indicies_second>
+        constexpr pair(tuple_first &first_tuple, tuple_second &second_tuple, hud::index_sequence<indicies_first...>, hud::index_sequence<indicies_second...>) noexcept
+            : first(hud::get<indicies_first>(hud::move(first_tuple))...)
+            , second(hud::get<indicies_second>(hud::move(second_tuple))...)
         {
         }
     };

test/hashmap/hashmap_add.cpp

@@ -4990,14 +4990,143 @@ GTEST_TEST(hashmap, add_by_piecewise_construct_bitwise_same_type)
         constexpr usize reserved_size = 2;
         hashmap_type map;
         map.reserve(reserved_size);
-        // map.add(hud::tag_piecewise_construct, hud::forward_as_tuple(1), hud::forward_as_tuple(2));
+        const auto it = map.add(hud::tag_piecewise_construct, hud::forward_as_tuple(1), hud::forward_as_tuple(2));
+        return hud::tuple {
+            map.count() == 1, // 0
+            it->key() == 1,   // 1
+            it->value() == 2  // 2
+        };
+    };
+
+    // Non constant
+    {
+        const auto result = test();
+        hud_assert_true(hud::get<0>(result));
+        hud_assert_true(hud::get<1>(result));
+        hud_assert_true(hud::get<2>(result));
+    }
+
+    // Constant
+    {
+        constexpr auto result = test();
+        hud_assert_true(hud::get<0>(result));
+        hud_assert_true(hud::get<1>(result));
+        hud_assert_true(hud::get<2>(result));
+    }
+}
+
+GTEST_TEST(hashmap, add_by_piecewise_construct_bitwise_different_type)
+{
+    using key_type = i32;
+    using value_type = i64;
+    using other_key_type = u32;
+    using other_value_type = u64;
+    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;
+        hashmap_type map;
+        map.reserve(reserved_size);
+        const auto it = map.add(hud::tag_piecewise_construct, hud::forward_as_tuple(other_key_type {1}), hud::forward_as_tuple(other_value_type {2}));
+
+        return hud::tuple {
+            map.count() == 1, // 0
+            it->key() == 1,   // 1
+            it->value() == 2  // 2
+        };
+    };
+
+    // Non constant
+    {
+        const auto result = test();
+        hud_assert_true(hud::get<0>(result));
+        hud_assert_true(hud::get<1>(result));
+        hud_assert_true(hud::get<2>(result));
+    }
+
+    // Constant
+    {
+        constexpr auto result = test();
+        hud_assert_true(hud::get<0>(result));
+        hud_assert_true(hud::get<1>(result));
+        hud_assert_true(hud::get<2>(result));
+    }
+}
+
+GTEST_TEST(hashmap, add_by_piecewise_construct_non_bitwise_same_type)
+{
+    using key_type = hud_test::non_bitwise_type;
+    using value_type = 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>>;
+
+    static_assert(hud::is_hashable_64_v<key_type, hud::tuple<i32, i32 *>>);
+    static_assert(hud::is_comparable_with_equal_v<key_type, hud::tuple<i32, i32 *>>);
+
+    const auto test = []()
+    {
+        constexpr usize reserved_size = 2;
+        i32 ptr[2];
+        hashmap_type map;
+        map.reserve(reserved_size);
+        const auto it = map.add(hud::tag_piecewise_construct, hud::forward_as_tuple(1, ptr), hud::forward_as_tuple(2, ptr + 1));
+
+        return hud::tuple {
+            map.count() == 1,                           // 0
+            it->key().constructor_count() == 1,         // 1
+            it->key().move_constructor_count() == 0,    // 2
+            it->key().copy_constructor_count() == 0,    // 3
+            it->key().move_assign_count() == 0,         // 4
+            it->key().copy_assign_count() == 0,         // 5
+            it->key().id() == 1,                        // 6
+            it->key().destructor_counter() == ptr,      // 7
+            it->value().constructor_count() == 1,       // 8
+            it->value().move_constructor_count() == 0,  // 9
+            it->value().copy_constructor_count() == 0,  // 10
+            it->value().move_assign_count() == 0,       // 11
+            it->value().copy_assign_count() == 0,       // 12
+            it->value().id() == 2,                      // 13
+            it->value().destructor_counter() == ptr + 1 // 14
+        };
     };
 
     // Non constant
     {
+        const auto result = test();
+        hud_assert_true(hud::get<0>(result));
+        hud_assert_true(hud::get<1>(result));
+        hud_assert_true(hud::get<2>(result));
+        hud_assert_true(hud::get<3>(result));
+        hud_assert_true(hud::get<4>(result));
+        hud_assert_true(hud::get<5>(result));
+        hud_assert_true(hud::get<6>(result));
+        hud_assert_true(hud::get<7>(result));
+        hud_assert_true(hud::get<8>(result));
+        hud_assert_true(hud::get<9>(result));
+        hud_assert_true(hud::get<10>(result));
+        hud_assert_true(hud::get<11>(result));
+        hud_assert_true(hud::get<12>(result));
+        hud_assert_true(hud::get<13>(result));
+        hud_assert_true(hud::get<14>(result));
     }
 
     // Constant
     {
+        constexpr auto result = test();
+        hud_assert_true(hud::get<0>(result));
+        hud_assert_true(hud::get<1>(result));
+        hud_assert_true(hud::get<2>(result));
+        hud_assert_true(hud::get<3>(result));
+        hud_assert_true(hud::get<4>(result));
+        hud_assert_true(hud::get<5>(result));
+        hud_assert_true(hud::get<6>(result));
+        hud_assert_true(hud::get<7>(result));
+        hud_assert_true(hud::get<8>(result));
+        hud_assert_true(hud::get<9>(result));
+        hud_assert_true(hud::get<10>(result));
+        hud_assert_true(hud::get<11>(result));
+        hud_assert_true(hud::get<12>(result));
+        hud_assert_true(hud::get<13>(result));
+        hud_assert_true(hud::get<14>(result));
     }
 }

test/misc/non_bitwise_type.h

@@ -2,6 +2,7 @@
 #define HD_INC_MISC_NON_BITWISE_TYPE_H
 #include <core/minimal.h>
 #include <core/templates/equal.h>
+#include <core/containers/tuple.h>
 
 namespace hud_test
 {
@@ -200,6 +201,11 @@ namespace hud_test
         return left.id() == id;
     }
 
+    [[nodiscard]] HD_FORCEINLINE constexpr bool operator==(const non_bitwise_type &left, const hud::tuple<i32, i32 *> &rhs) noexcept
+    {
+        return left.id() == hud::get<0>(rhs);
+    }
+
     static_assert(hud::is_move_constructible_v<non_bitwise_type>);
     static_assert(hud::is_copy_constructible_v<non_bitwise_type>);
     static_assert(hud::is_move_assignable_v<non_bitwise_type>);
@@ -253,6 +259,11 @@ namespace hud
         {
             return lhs == rhs;
         }
+
+        [[nodiscard]] constexpr bool operator()(const hud_test::non_bitwise_type &lhs, const hud::tuple<i32, i32 *> &rhs) const noexcept
+        {
+            return lhs == hud::get<0>(rhs);
+        }
     };
 
     template<>
@@ -262,6 +273,16 @@ namespace hud
         {
             return hud::hash_32<i32> {}(custom.id());
         }
+
+        [[nodiscard]] constexpr u32 operator()(const i32 id) const
+        {
+            return hud::hash_32<i32> {}(id);
+        }
+
+        [[nodiscard]] constexpr bool operator()(const hud::tuple<i32, i32 *> &rhs) const noexcept
+        {
+            return hud::hash_32<i32> {}(hud::get<0>(rhs));
+        }
     };
 
     template<>
@@ -276,6 +297,11 @@ namespace hud
         {
             return hud::hash_64<i32> {}(id);
         }
+
+        [[nodiscard]] constexpr bool operator()(const hud::tuple<i32, i32 *> &rhs) const noexcept
+        {
+            return hud::hash_64<i32> {}(hud::get<0>(rhs));
+        }
     };
 
     template<>
@@ -285,6 +311,16 @@ namespace hud
         {
             return hud::hash_32<i32> {}(custom.id());
         }
+
+        [[nodiscard]] constexpr u32 operator()(const i32 id) const
+        {
+            return hud::hash_32<i32> {}(id);
+        }
+
+        [[nodiscard]] constexpr bool operator()(const hud::tuple<i32, i32 *> &rhs) const noexcept
+        {
+            return hud::hash_32<i32> {}(hud::get<0>(rhs));
+        }
     };
 
     template<>
@@ -294,6 +330,16 @@ namespace hud
         {
             return hud::hash_64<i32> {}(custom.id());
         }
+
+        [[nodiscard]] constexpr u64 operator()(const i32 id) const
+        {
+            return hud::hash_64<i32> {}(id);
+        }
+
+        [[nodiscard]] constexpr bool operator()(const hud::tuple<i32, i32 *> &rhs) const noexcept
+        {
+            return hud::hash_64<i32> {}(hud::get<0>(rhs));
+        }
     };
 } // namespace hud