Fixes to source code after the API changes.

Author: Dandielo

source/code/core/core/public/ice/hash.hxx

@@ -1,10 +1,11 @@
-/// Copyright 2022 - 2025, Dandielo <dandielo@iceshard.net>
+/// Copyright 2022 - 2026, Dandielo <dandielo@iceshard.net>
 /// SPDX-License-Identifier: MIT
 
 #pragma once
 #include <ice/constants.hxx>
 #include <ice/hash/murmur2.hxx>
 #include <ice/hash/murmur3.hxx>
+#include <ice/utility.hxx>
 
 namespace ice
 {
@@ -52,6 +53,7 @@ namespace ice
     template<typename T>
     constexpr auto hash(T value) noexcept -> ice::u64
     {
+        static_assert(ice::concepts::EnumOrIntegral<T>);
         return static_cast<ice::u64>(value);
     }
 

source/code/core/core/public/ice/utility.hxx

@@ -104,4 +104,13 @@ namespace ice
         );
     }
 
+    namespace concepts
+    {
+
+        template<typename T>
+        concept EnumOrIntegral = std::is_enum_v<T>
+            or (std::is_arithmetic_v<T> && not std::is_floating_point_v<T>);
+
+    } // namespace concepts
+
 } // namespace ice

source/code/core/modules/private/module_register.cxx

@@ -2,15 +2,15 @@
 /// SPDX-License-Identifier: MIT
 
 #include <ice/module_register.hxx>
-#include <ice/array.hxx>
-#include <ice/container/hashmap.hxx>
+#include <ice/multi_hashmap.hxx>
 #include <ice/heap_string.hxx>
 #include <ice/os/windows.hxx>
 #include <ice/os/unix.hxx>
 #include <ice/profiler.hxx>
 
 #include "module_globals.hxx"
 #include "module_native.hxx"
+#include <ice/hashmap.hxx>
 
 namespace ice
 {
@@ -73,7 +73,7 @@ namespace ice
 
     private:
         ice::Allocator& _allocator;
-        ice::HashMap<DefaultModuleEntry> _modules;
+        ice::MultiHashMap<DefaultModuleEntry> _modules;
         ice::Array<ice::native_module::ModuleHandle> _module_handles;
     };
 
@@ -170,15 +170,15 @@ namespace ice
     ) const noexcept -> ice::u32
     {
         ice::u32 result = 0;
-        auto it = ice::multi_hashmap::find_first(_modules, ice::hash(api_name));
+        auto it = _modules.find_values(api_name);
         while (it != nullptr)
         {
             ice::ModuleAPI api_ptr;
             if (it.value().select_api(ice::stringid_hash(api_name), version, &api_ptr))
             {
                 result += 1;
             }
-            it = ice::multi_hashmap::find_next(_modules, it);
+            it.next();
         }
         return result;
     }
@@ -202,7 +202,7 @@ namespace ice
         }
 
         ice::u32 idx = 0;
-        auto it = ice::multi_hashmap::find_first(_modules, ice::hash(api_name));
+        auto it = _modules.find_values(api_name);
 
         ice::u32 const array_size = *inout_array_size;
         while (it != nullptr && idx < array_size)
@@ -213,7 +213,7 @@ namespace ice
                 out_array[idx] = api_ptr;
                 idx += 1;
             }
-            it = ice::multi_hashmap::find_next(_modules, it);
+            it.next();
         }
         return idx > 0;
     }
@@ -223,7 +223,7 @@ namespace ice
     ) noexcept
     {
         ice::u64 const name_hash = ice::hash(entry.name);
-        ice::multi_hashmap::insert(_modules, name_hash, entry);
+        _modules.insert(name_hash, entry);
         return true;
     }
 

source/code/core/modules/public/ice/module_register.hxx

@@ -4,9 +4,8 @@
 #pragma once
 #include <ice/mem_unique_ptr.hxx>
 #include <ice/mem_allocator_stack.hxx>
-#include <ice/string_types.hxx>
+#include <ice/string.hxx>
 #include <ice/stringid.hxx>
-#include <ice/container_types.hxx>
 #include <ice/array.hxx>
 #include <ice/module_negotiator.hxx>
 #include <ice/module_query.hxx>

source/code/core/tasks/private/task_native_thread.cxx

@@ -50,7 +50,7 @@ namespace ice
         while (_runtime._state != ThreadState::Destroyed)
         {
             _runtime._queue.push_back(&final_awaitable);
-            thread_native::sleep(1);
+            thread_native::sleep(3); // sleep for a few milliseconds to ensure the thread was destroyed
         }
 
         thread_native::destroy_thread(_native);

source/code/core/tasks/private/task_thread_pool_impl.cxx

@@ -134,22 +134,21 @@ namespace ice
             .debug_name = ice::String{ name_hint.data(), static_cast<ice::u32>(name_hint.size()) }
         };
 
-        ice::hashmap::set(
-            _created_threads,
-            ice::hash(name),
+        _created_threads.set(
+            name,
             ice::make_unique<ice::NativeTaskThread>(
                 _allocator,
                 _queue,
                 thread_info
             )
         );
 
-        return **ice::hashmap::try_get(_created_threads, ice::hash(name));
+        return **_created_threads.try_get(ice::hash(name));
     }
 
     auto TaskThreadPoolImplementation::find_thread(ice::StringID name) noexcept -> ice::TaskThread*
     {
-        if (auto const& unique_ptr = ice::hashmap::try_get(_created_threads, ice::hash(name)))
+        if (auto const& unique_ptr = _created_threads.try_get(ice::hash(name)))
         {
             return unique_ptr->get();
         }
@@ -158,13 +157,7 @@ namespace ice
 
     bool TaskThreadPoolImplementation::destroy_thread(ice::StringID name) noexcept
     {
-        ice::u64 const name_hash = ice::hash(name);
-        bool const exists = _created_threads.has(name_hash);
-        if (exists)
-        {
-            ice::hashmap::remove(_created_threads, name_hash);
-        }
-        return exists;
+        return _created_threads.remove(name);
     }
 
     auto TaskThreadPoolImplementation::attach_thread(
@@ -173,20 +166,13 @@ namespace ice
         ice::UniquePtr<ice::TaskThread> thread
     ) noexcept -> ice::TaskThread&
     {
-        ice::u64 const name_hash = ice::hash(name);
         ICE_ASSERT(
-            _user_threads.missing(name_hash),
+            _user_threads.missing(name),
             "A user thread with name '{}' already exists",
             name
         );
 
-        ice::hashmap::set(
-            _user_threads,
-            name_hash,
-            ice::move(thread)
-        );
-
-        return **ice::hashmap::try_get(_user_threads, name_hash);
+        return *_user_threads.set(name, ice::move(thread));
     }
 
     auto TaskThreadPoolImplementation::detach_thread(
@@ -198,9 +184,9 @@ namespace ice
         if (_user_threads.has(name_hash))
         {
             // Move the thread out of the map
-            result = ice::move(*ice::hashmap::try_get(_user_threads, name_hash));
+            result = ice::move(*_user_threads.try_get(name_hash));
             // Remove the element from the map
-            ice::hashmap::remove(_user_threads, name_hash);
+            _user_threads.remove(name_hash);
         }
         return result;
     }

source/code/core/tasks/private/task_thread_pool_impl.hxx

@@ -5,7 +5,7 @@
 #include <ice/task_thread_pool.hxx>
 #include <ice/task_flags.hxx>
 #include <ice/array.hxx>
-#include <ice/container/hashmap.hxx>
+#include <ice/hashmap.hxx>
 #include "task_native_thread.hxx"
 
 namespace ice

source/code/core/tasks/public/ice/task_thread.hxx

@@ -4,7 +4,7 @@
 #pragma once
 #include <ice/task_types.hxx>
 #include <ice/mem_unique_ptr.hxx>
-#include <ice/string_types.hxx>
+#include <ice/string.hxx>
 
 namespace ice
 {

source/code/core/tasks/public/ice/task_thread_pool.hxx

@@ -5,7 +5,7 @@
 #include <ice/task_types.hxx>
 #include <ice/mem_unique_ptr.hxx>
 #include <ice/native_aio.hxx>
-#include <ice/string_types.hxx>
+#include <ice/string.hxx>
 #include <ice/span.hxx>
 
 namespace ice

source/code/core/utils/private/config/config_builder.cxx

@@ -2,7 +2,7 @@
 /// SPDX-License-Identifier: MIT
 
 #include <ice/config/config_builder.hxx>
-#include <ice/container/hashmap.hxx>
+#include <ice/multi_hashmap.hxx>
 #include <ice/heap_string.hxx>
 #include <ice/heap_varstring.hxx>
 
@@ -47,20 +47,20 @@ namespace ice
         ice::u32 offset_strings;
     };
 
-    auto cb_find_keystr_idx(ice::HashMap<CBKeyString> const& keystrings, ice::String keystr) noexcept -> ice::u32
+    auto cb_find_keystr_idx(ice::MultiHashMap<CBKeyString> const& keystrings, ice::String keystr) noexcept -> ice::u32
     {
         ice::u64 const keystr_hash = ice::hash(keystr);
-        auto it = ice::multi_hashmap::find_first(keystrings, keystr_hash);
+        auto it = keystrings.find_values(keystr_hash);
         while(it != nullptr && it.value().value != keystr)
         {
-            it = ice::multi_hashmap::find_next(keystrings, it);
+            it.next();
         }
 
         return it == nullptr ? keystrings.size().u32() : it.value().index;
     }
 
     auto cb_calculate_key_size(
-        ice::HashMap<CBKeyString>& keystrings,
+        ice::MultiHashMap<CBKeyString>& keystrings,
         ice::config::detail::ConfigBuilderContainer const& config,
         ice::config::detail::ConfigBuilderEntry const* entry
     ) noexcept -> ice::usize
@@ -76,15 +76,15 @@ namespace ice
             //   This allows us to reuse duplicate key names
             if (keystr_idx == keystrings.size())
             {
-                ice::multi_hashmap::insert(keystrings, ice::hash(keystr), { keystr, keystr_idx });
+                keystrings.insert(keystr, { keystr, keystr_idx });
                 result += { entry->size }; // Increase the size required
             }
         }
         return result;
     }
 
     auto cb_calculate_final_size(
-        ice::HashMap<CBKeyString>& keystrings,
+        ice::MultiHashMap<CBKeyString>& keystrings,
         ice::config::detail::ConfigBuilderContainer const& config,
         ice::usize& out_data_size,
         ice::u32& out_count
@@ -138,7 +138,7 @@ namespace ice
     }
 
     auto cb_calculate_final_size(
-        ice::HashMap<CBKeyString>& keystrings,
+        ice::MultiHashMap<CBKeyString>& keystrings,
         ice::config::detail::ConfigBuilderContainer const& config,
         ice::u32& out_count
     ) noexcept -> ice::usize
@@ -157,7 +157,7 @@ namespace ice
     }
 
     auto cb_finalize_store_keysvalues(
-        ice::HashMap<CBKeyString>& keystrings,
+        ice::MultiHashMap<CBKeyString>& keystrings,
         ice::Span<ice::u32 const> keystringoffsets,
         ice::config::detail::ConfigBuilderContainer const& config,
         ice::config::detail::ConfigKey* out_keylist,
@@ -377,7 +377,7 @@ namespace ice
         }
 
         ice::Array<ice::u32> keyoffsets{ alloc };
-        ice::HashMap<ice::CBKeyString> keystrings{ alloc };
+        ice::MultiHashMap<ice::CBKeyString> keystrings{ alloc };
 
         ice::u32 final_count = 0;
         ice::usize const final_size = cb_calculate_final_size(keystrings, container, final_count);