Improve hashset hashmap

Author: Julian LALU

interface/core/containers/hashmap.h

@@ -282,6 +282,14 @@ namespace hud
     public:
         /** Type of the hash function. */
         using typename super::hasher_type;
+        /** Type of the equal function. */
+        using typename super::key_equal_type;
+        /** Type of the iterator. */
+        using typename super::iterator;
+        /** Type of the const iterator. */
+        using typename super::const_iterator;
+        /**  Type of the allocator. */
+        using typename super::allocator_type;
         /** Type of the storage used to store key-value pairs. */
         using storage_type = typename super::storage_type;
         /** Type of the key. */
@@ -292,9 +300,6 @@ namespace hud
         /** Inherit constructors and methods from the base class. */
         using super::reserve;
         using super::super;
-        using typename super::allocator_type;
-        using typename super::const_iterator;
-        using typename super::iterator;
         using super::operator=;
 
         /** Default constructor. */

interface/core/containers/hashset.h

@@ -797,22 +797,6 @@ namespace hud
             slot_type *slot_ptr_;
         };
 
-        // template<bool is_transparent>
-        // struct KeyArg
-        // {
-        //     // Transparent. Forward `K`.
-        //     template<typename K, typename key_type>
-        //     using type = K;
-        // };
-
-        // template<>
-        // struct KeyArg<false>
-        // {
-        //     // Not transparent. Always use `key_type`.
-        //     template<typename K, typename key_type>
-        //     using type = key_type;
-        // };
-
         template<
             typename storage_t,
             typename hasher_t,
@@ -1184,25 +1168,6 @@ namespace hud
                 return res.first;
             }
 
-            // /**
-            //  * Finds or inserts a slot corresponding to the given key.
-            //  * If the key is not found, a new slot is created by constructing it with the key followed by `args`.
-            //  * @param key The key used to find or insert the slot.
-            //  * @param args The arguments forwarded to the `slot_type` constructor after the key.
-            //  * @return An iterator to the inserted or existing value.
-            //  */
-            // template<typename... args_t>
-            // requires(hud::is_constructible_v<slot_type, const key_type &, args_t...>)
-            // constexpr iterator add_impl(const key_type &key, args_t &&...args) noexcept
-            // {
-            //     hud::pair<iterator, bool> res {find_or_insert_no_construct(key)};
-            //     if (res.second)
-            //     {
-            //         hud::memory::construct_object_at(res.first.slot_ptr_, key, hud::forward<args_t>(args)...);
-            //     }
-            //     return res.first;
-            // }
-
             /**
              * Adds a new element to the container using piecewise construction of the key and value.
              *
@@ -2034,16 +1999,22 @@ namespace hud
     public:
         /** Type of the hash function. */
         using typename super::hasher_type;
-        /** Type of the storage used to store key-value pairs. */
+        /** Type of the equal function. */
+        using typename super::key_equal_type;
+        /** Type of the iterator. */
+        using typename super::iterator;
+        /** Type of the const iterator. */
+        using typename super::const_iterator;
+        /**  Type of the allocator. */
+        using typename super::allocator_type;
+        /** Type of the storage used to store key. */
         using storage_type = typename super::storage_type;
         /** Type of the key. */
         using key_type = typename storage_type::key_type;
+
         /** Inherit constructors and methods from the base class. */
         using super::reserve;
         using super::super;
-        using typename super::allocator_type;
-        using typename super::const_iterator;
-        using typename super::iterator;
         using super::operator=;
 
         explicit constexpr hashset() noexcept = default;

test/hashmap/hashmap_misc.cpp

@@ -130,3 +130,22 @@ GTEST_TEST(hashmap, count_return_count_of_element)
         hud_assert_true(std::get<2>(result));
     }
 }
+
+GTEST_TEST(hashmap, sizeof_map_is_correct)
+{
+    // Size of hashmap do not depends of the key and value types
+    hud_assert_true(sizeof(hud::hashmap<i32, i32>) == sizeof(hud::hashmap<i64, i64>));
+
+    // hashmp is compressed, all empty element like allocator, comparator, hasher must be 0 size
+    // This test must be updated if the member of hashmap is changed
+    constexpr usize allocator_size = sizeof(hud::hashmap<i32, i32>::allocator_type);
+    constexpr usize hasher_size = sizeof(hud::hashmap<i32, i32>::hasher_type);
+    constexpr usize equal_size = sizeof(hud::hashmap<i32, i32>::key_equal_type);
+    constexpr usize control_ptr_size = sizeof(void *);
+    constexpr usize slot_ptr_size = sizeof(void *);
+    constexpr usize count_and_max_count_and_free_slot_before_grow_size = 3 * sizeof(usize);
+
+    constexpr usize sizeof_map = sizeof(hud::hashmap<i32, i32>);
+    hud_assert_true(sizeof_map == 48);
+    hud_assert_true(sizeof_map >= (allocator_size + hasher_size + equal_size + control_ptr_size + slot_ptr_size + count_and_max_count_and_free_slot_before_grow_size));
+}