From 274a992199a0711bd1f264b6c319d869b2f76e99 Mon Sep 17 00:00:00 2001
From: Julian LALU <julian.lalu@outlook.fr>
Date: Thu, 23 Jan 2025 16:45:29 +0100
Subject: [PATCH] Improve hashmap and hashset

---
 interface/core/containers/hashmap.h |  18 ++-
 interface/core/containers/hashset.h |  21 ++-
 test/hashmap/hashmap_iterator.cpp   | 220 +++++++++++++++-------------
 3 files changed, 149 insertions(+), 110 deletions(-)

diff --git a/interface/core/containers/hashmap.h b/interface/core/containers/hashmap.h
index 34eeafd..bc01d22 100644
--- a/interface/core/containers/hashmap.h
+++ b/interface/core/containers/hashmap.h
@@ -63,13 +63,13 @@ namespace hud
             }
 
             template<usize idx_to_reach>
-            [[nodiscard]] friend constexpr decltype(auto) get(slot &&s) noexcept
+            [[nodiscard]] friend constexpr auto get(slot &&s) noexcept
             {
                 return hud::get<idx_to_reach>(hud::forward<slot>(s).element_);
             }
 
             template<usize idx_to_reach>
-            [[nodiscard]] friend constexpr decltype(auto) get(const slot &&s) noexcept
+            [[nodiscard]] friend constexpr auto get(const slot &&s) noexcept
             {
                 return hud::get<idx_to_reach>(hud::forward<const slot>(s).element_);
             }
@@ -191,4 +191,18 @@ namespace hud
 
 } // namespace hud
 
+namespace std
+{
+    template<typename key_t, typename value_t>
+    struct tuple_size<hud::details::hashmap::slot<key_t, value_t>>
+        : hud::tuple_size<hud::details::hashmap::slot<key_t, value_t>>
+    {
+    };
+
+    template<std::size_t idx_to_reach, typename key_t, typename value_t>
+    struct tuple_element<idx_to_reach, hud::details::hashmap::slot<key_t, value_t>>
+        : hud::tuple_element<idx_to_reach, hud::details::hashmap::slot<key_t, value_t>>
+    {
+    };
+} // namespace std
 #endif // HD_INC_CORE_HASHMAP_H
\ No newline at end of file
diff --git a/interface/core/containers/hashset.h b/interface/core/containers/hashset.h
index b8d214b..0da80af 100644
--- a/interface/core/containers/hashset.h
+++ b/interface/core/containers/hashset.h
@@ -475,11 +475,6 @@ namespace hud
                 HD_ASSUME(slot_ptr_ != nullptr);
             }
 
-            // constexpr iterator(const iterator<slot_type, false> &it) noexcept
-            //     : iterator(it.control_ptr_, it.slot_ptr_)
-            // {
-            // }
-
             /**
              * Create a constant iterator from a non constant iterator.
              */
@@ -553,13 +548,13 @@ namespace hud
             }
 
             template<usize idx_to_reach>
-            [[nodiscard]] friend constexpr decltype(auto) get(iterator &&s) noexcept
+            [[nodiscard]] friend constexpr auto get(iterator &&s) noexcept
             {
                 return get<idx_to_reach>(*(hud::forward<iterator>(s).slot_ptr_));
             }
 
             template<usize idx_to_reach>
-            [[nodiscard]] friend constexpr decltype(auto) get(const iterator &&s) noexcept
+            [[nodiscard]] friend constexpr auto get(const iterator &&s) noexcept
             {
                 return get<idx_to_reach>(*(hud::forward<const iterator>(s).slot_ptr_));
             }
@@ -1172,6 +1167,18 @@ namespace hud
 
 namespace std
 {
+    template<typename key_t>
+    struct tuple_size<hud::details::hashset::slot<key_t>>
+        : hud::tuple_size<hud::details::hashset::slot<key_t>>
+    {
+    };
+
+    template<std::size_t idx_to_reach, typename key_t>
+    struct tuple_element<idx_to_reach, hud::details::hashset::slot<key_t>>
+        : hud::tuple_element<idx_to_reach, hud::details::hashset::slot<key_t>>
+    {
+    };
+
     template<typename slot_t, bool is_const>
     struct tuple_size<hud::details::hashset::iterator<slot_t, is_const>>
         : hud::tuple_size<hud::details::hashset::iterator<slot_t, is_const>>
diff --git a/test/hashmap/hashmap_iterator.cpp b/test/hashmap/hashmap_iterator.cpp
index b95b71f..14b1ddb 100644
--- a/test/hashmap/hashmap_iterator.cpp
+++ b/test/hashmap/hashmap_iterator.cpp
@@ -84,7 +84,7 @@ GTEST_TEST(hashmap, structure_binding)
         hud_assert_eq(second_c, 11);
     }
 
-    // auto is a reference
+    // auto is a copy
     {
         hud::hashmap<i32, i64> map;
         map.add({1, 11});
@@ -100,116 +100,134 @@ GTEST_TEST(hashmap, structure_binding)
         hud_assert_eq(second, 111);
         auto [first_1, second_1] = map.find(1);
         hud_assert_eq(first_1, 1);
+        hud_assert_eq(second_1, 11);
+    }
+
+    // auto& is a reference
+    {
+        hud::hashmap<i32, i64> map;
+        map.add({1, 11});
+        map.add({2, 22});
+        map.add({3, 33});
+        map.add({4, 44});
+        hud_assert_eq(map.count(), 4u);
+        hud_assert_ge(map.max_count(), 4u);
+        auto it = map.find(1);
+        auto &[first, second] = it;
+        hud_assert_eq(first, 1);
+        second = 111;
+        hud_assert_eq(second, 111);
+        auto [first_1, second_1] = map.find(1);
+        hud_assert_eq(first_1, 1);
         hud_assert_eq(second_1, 111);
     }
 
-    // // Ref do modify hash value
-    // {
-    //     hud::hashmap<i32, hud_test::non_bitwise_copy_assignable_type> map;
-    //     map.add({1, 11});
-    //     map.add({2, 22});
-    //     map.add({3, 33});
-    //     map.add({4, 44});
-    //     hud_assert_eq(map.count(), 4u);
-    //     hud_assert_ge(map.max_count(), 4u);
-    //     auto it = map.find(4);
-    //     auto &[first, second] = *it;
-    //     hud_assert_eq(first, 4);
-    //     second = 444;
-    //     hud_assert_eq(second, 444);
-    //     auto it_1 = map.find(4);
-    //     auto &[first_1, second_1] = *it_1;
-    //     hud_assert_eq(first_1, 4);
-    //     hud_assert_eq(second_1, 444);
-    // }
+    // auto&& is a reference
+    {
+        hud::hashmap<i32, i64> map;
+        map.add({1, 11});
+        map.add({2, 22});
+        map.add({3, 33});
+        map.add({4, 44});
+        hud_assert_eq(map.count(), 4u);
+        hud_assert_ge(map.max_count(), 4u);
+        auto it = map.find(1);
+        auto &[first, second] = it;
+        hud_assert_eq(first, 1);
+        second = 111;
+        hud_assert_eq(second, 111);
+        auto [first_1, second_1] = map.find(1);
+        hud_assert_eq(first_1, 1);
+        hud_assert_eq(second_1, 111);
+    }
 
-    // // Loop
-    // {
-    //     const auto test = []()
-    //     {
-    //         using map_type = hud::hashmap<i32, i64>;
-    //         map_type map {
-    //             {1, 11},
-    //             {2, 22},
-    //             {3, 33},
-    //             {4, 44}
-    //         };
-    //         const map_type const_map {
-    //             {1, 11},
-    //             {2, 22},
-    //             {3, 33},
-    //             {4, 44}
-    //         };
+    // Loop
+    {
+        const auto test = []()
+        {
+            using map_type = hud::hashmap<i32, i64>;
+            map_type map {
+                {1, 11},
+                {2, 22},
+                {3, 33},
+                {4, 44}
+            };
+            const map_type const_map {
+                {1, 11},
+                {2, 22},
+                {3, 33},
+                {4, 44}
+            };
 
-    // map_type::element_type result[4];
-    // usize index = 0;
-    // for (const auto &[first, second] : map)
-    // {
-    //     result[index++] = {first, second};
-    // }
+            hud::pair<map_type::key_type, map_type::value_type> result[4];
+            usize index = 0;
+            for (const auto &[first, second] : map)
+            {
+                result[index++] = {first, second};
+            }
 
-    // map_type::element_type const_result[4];
-    // index = 0;
-    // for (const auto &[first, second] : const_map)
-    // {
-    //     const_result[index++] = {first, second};
-    // }
-    // i32 pair_1_11_index = hud::find_index_if(result, 4, [](const auto &pair)
-    //                                          { return pair.first == 1 && pair.second == 11; });
-    // i32 pair_2_22_index = hud::find_index_if(result, 4, [](const auto &pair)
-    //                                          { return pair.first == 2 && pair.second == 22; });
-    // i32 pair_3_33_index = hud::find_index_if(result, 4, [](const auto &pair)
-    //                                          { return pair.first == 3 && pair.second == 33; });
-    // i32 pair_4_44_index = hud::find_index_if(result, 4, [](const auto &pair)
-    //                                          { return pair.first == 4 && pair.second == 44; });
+            hud::pair<map_type::key_type, map_type::value_type> const_result[4];
+            index = 0;
+            for (const auto &[first, second] : const_map)
+            {
+                const_result[index++] = {first, second};
+            }
+            i32 pair_1_11_index = hud::find_index_if(result, 4, [](const auto &pair)
+                                                     { return pair.first == 1 && pair.second == 11; });
+            i32 pair_2_22_index = hud::find_index_if(result, 4, [](const auto &pair)
+                                                     { return pair.first == 2 && pair.second == 22; });
+            i32 pair_3_33_index = hud::find_index_if(result, 4, [](const auto &pair)
+                                                     { return pair.first == 3 && pair.second == 33; });
+            i32 pair_4_44_index = hud::find_index_if(result, 4, [](const auto &pair)
+                                                     { return pair.first == 4 && pair.second == 44; });
 
-    // i32 const_pair_1_11_index = hud::find_index_if(const_result, 4, [](const auto &pair)
-    //                                                { return pair.first == 1 && pair.second == 11; });
-    // i32 const_pair_2_22_index = hud::find_index_if(const_result, 4, [](const auto &pair)
-    //                                                { return pair.first == 2 && pair.second == 22; });
-    // i32 const_pair_3_33_index = hud::find_index_if(const_result, 4, [](const auto &pair)
-    //                                                { return pair.first == 3 && pair.second == 33; });
-    // i32 const_pair_4_44_index = hud::find_index_if(const_result, 4, [](const auto &pair)
-    //                                                { return pair.first == 4 && pair.second == 44; });
+            i32 const_pair_1_11_index = hud::find_index_if(const_result, 4, [](const auto &pair)
+                                                           { return pair.first == 1 && pair.second == 11; });
+            i32 const_pair_2_22_index = hud::find_index_if(const_result, 4, [](const auto &pair)
+                                                           { return pair.first == 2 && pair.second == 22; });
+            i32 const_pair_3_33_index = hud::find_index_if(const_result, 4, [](const auto &pair)
+                                                           { return pair.first == 3 && pair.second == 33; });
+            i32 const_pair_4_44_index = hud::find_index_if(const_result, 4, [](const auto &pair)
+                                                           { return pair.first == 4 && pair.second == 44; });
 
-    // return std::tuple {
-    //     pair_1_11_index != -1,
-    //     pair_2_22_index != -1,
-    //     pair_3_33_index != -1,
-    //     pair_4_44_index != -1,
-    //     const_pair_1_11_index != -1,
-    //     const_pair_2_22_index != -1,
-    //     const_pair_3_33_index != -1,
-    //     const_pair_4_44_index != -1,
-    // };
-    // };
+            return std::tuple {
+                pair_1_11_index != -1,
+                pair_2_22_index != -1,
+                pair_3_33_index != -1,
+                pair_4_44_index != -1,
+                const_pair_1_11_index != -1,
+                const_pair_2_22_index != -1,
+                const_pair_3_33_index != -1,
+                const_pair_4_44_index != -1,
+            };
+        };
 
-    // // 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));
-    //     hud_assert_true(std::get<3>(result));
-    //     hud_assert_true(std::get<4>(result));
-    //     hud_assert_true(std::get<5>(result));
-    //     hud_assert_true(std::get<6>(result));
-    //     hud_assert_true(std::get<7>(result));
-    // }
+        // 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));
+            hud_assert_true(std::get<3>(result));
+            hud_assert_true(std::get<4>(result));
+            hud_assert_true(std::get<5>(result));
+            hud_assert_true(std::get<6>(result));
+            hud_assert_true(std::get<7>(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));
-    //     hud_assert_true(std::get<3>(result));
-    //     hud_assert_true(std::get<4>(result));
-    //     hud_assert_true(std::get<5>(result));
-    //     hud_assert_true(std::get<6>(result));
-    //     hud_assert_true(std::get<7>(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));
+            hud_assert_true(std::get<3>(result));
+            hud_assert_true(std::get<4>(result));
+            hud_assert_true(std::get<5>(result));
+            hud_assert_true(std::get<6>(result));
+            hud_assert_true(std::get<7>(result));
+        }
+    }
 }
 
 GTEST_TEST(hashmap, range_for_loop)