Improve hashmap

Author: Julian LALU

test/CMakeLists.txt

@@ -70,6 +70,8 @@ set( src
 	hashmap/hashmap_constructors.cpp
 	hashmap/hashmap_copy_assign_operator.cpp
 	hashmap/hashmap_copy_constructors.cpp
+	hashmap/hashmap_destructeur.cpp
+	hashmap/hashmap_indexed_operator.cpp
 	hashmap/hashmap_find.cpp
 	hashmap/hashmap_comparison.cpp
 	hashmap/hashmap_swap.cpp

test/hashmap/hashmap_destructeur.cpp

@@ -0,0 +1,73 @@
+#include <core/containers/hashmap.h>
+#include "../misc/allocator_watcher.h"
+
+GTEST_TEST(hashmap, destructor_call_elements_destructors)
+{
+
+    using key_type = hud_test::SetBoolToTrueWhenDestroyed;
+    using value_type = hud_test::SetBoolToTrueWhenDestroyed;
+    using hashmap_type = hud::hashmap<key_type, value_type>;
+
+    const auto test = []()
+    {
+        hashmap_type map;
+
+        const usize COUNT = 4;
+        i32 *dtor_assigned_key_counter = nullptr;
+        i32 *dtor_assigned_value_counter = nullptr;
+
+        dtor_assigned_key_counter = hud::memory::allocate_array<i32>(COUNT);
+        hud::memory::set_memory_zero_safe(dtor_assigned_key_counter, COUNT * sizeof(i32));
+        dtor_assigned_value_counter = hud::memory::allocate_array<i32>(COUNT);
+        hud::memory::set_memory_zero_safe(dtor_assigned_value_counter, COUNT * sizeof(i32));
+
+        hud_test::LeakArrayGuard guard_assigned_key_counter(dtor_assigned_key_counter, COUNT);
+        hud_test::LeakArrayGuard guard_assigned_value_counter(dtor_assigned_value_counter, COUNT);
+
+        bool all_keys_destructor_are_not_called = true;
+        bool all_values_destructor_are_not_called = true;
+        {
+            hashmap_type map;
+            map.reserve(COUNT);
+            for (i32 i = 0; i < COUNT; i++)
+            {
+                map.add({i, dtor_assigned_key_counter + i}, {i, dtor_assigned_value_counter + i});
+            }
+
+            // Ensure element's destructors are not called
+            for (i32 i = 0; i < COUNT; i++)
+            {
+                // Should be accepted with is_transparent
+                // const auto it = map.find(i);
+                const auto it = map.find({i, dtor_assigned_key_counter + i});
+                if (*(it->key().ptr()) != 0)
+                {
+                    all_keys_destructor_are_not_called = false;
+                }
+                if ((*it->value().ptr()) != 0)
+                {
+                    all_values_destructor_are_not_called = false;
+                }
+            }
+        }
+
+        return std::tuple {
+            all_keys_destructor_are_not_called,  // 0
+            all_values_destructor_are_not_called // 1
+        };
+    };
+
+    // 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));
+    }
+}

test/hashmap/hashmap_indexed_operator.cpp

@@ -0,0 +1 @@
+#include <core/containers/hashmap.h>

test/misc/set_bool_to_true_when_destroyed.h

@@ -154,6 +154,11 @@ namespace hud
         {
             return hud::hash_32<i32> {}(custom.id());
         }
+
+        [[nodiscard]] constexpr u32 operator()(const i32 custom) const
+        {
+            return hud::hash_32<i32> {}(custom);
+        }
     };
 
     template<>
@@ -163,7 +168,27 @@ namespace hud
         {
             return hud::hash_64<i32> {}(custom.id());
         }
+
+        [[nodiscard]] constexpr u32 operator()(const i32 custom) const
+        {
+            return hud::hash_32<i32> {}(custom);
+        }
     };
 
+    // template<>
+    // struct hash_32<string>
+    // {
+    //     std::size_t operator()(const string &s) const
+    //     {
+    //         return ...;
+    //     }
+
+    // // hash_equal=true allows hashing string literals
+    // std::size_t operator()(const char *s) const
+    // {
+    //     return ...;
+    // }
+    // };
+
 } // namespace hud
 #endif // HD_INC_MISC_SETBOOLTOTRUEWHENDESTROYED_H