Updating code affected after the refactor.

Author: Dandielo

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

@@ -3,7 +3,6 @@
 
 #pragma once
 #include <ice/task_promise.hxx>
-#include <ice/container_concepts.hxx>
 
 namespace ice
 {

source/code/framework/framework_base/private/framework_main.cxx

@@ -560,7 +560,7 @@ void ice_process_input_events(ice::Span<ice::input::InputEvent const> events, ic
 {
     for (ice::input::InputEvent const input_event : events)
     {
-        ice::shards::push_back(out_shards, ice::ShardID_InputEvent | input_event);
+        out_shards.push_back(ice::ShardID_InputEvent | input_event);
     }
 }
 
@@ -585,7 +585,7 @@ auto ice_game_frame(
     ICE_ASSERT(new_frame != nullptr, "Failed to aquire next frame!");
 
     // Push system events
-    ice::shards::push_back(new_frame->shards(), system_events._data);
+    new_frame->shards().push_back(system_events);
 
     // Push previous frame events
     //   Also runs other logic that should be done without interfeerence from
@@ -667,7 +667,7 @@ auto ice_update(
     ice::ShardContainer const& system_events = state.platform.core->system_events();
 
     // Query platform events into the frame and input device handler.
-    if (runtime.is_exiting || ice::shards::contains(system_events, ice::platform::Shard_AppQuit))
+    if (runtime.is_exiting || system_events.contains(ice::platform::Shard_AppQuit))
     {
         runtime.is_exiting = true;
 
@@ -690,11 +690,11 @@ auto ice_update(
         return ice::app::S_ApplicationExit;
     }
 
-    bool const was_resized = ice::shards::contains(system_events, ice::platform::ShardID_WindowResized);
-    bool const was_minimized = ice::shards::contains(system_events, ice::platform::ShardID_WindowMinimized);
-    bool const was_maximized = ice::shards::contains(system_events, ice::platform::ShardID_WindowMaximized);
+    bool const was_resized = system_events.contains(ice::platform::ShardID_WindowResized);
+    bool const was_minimized = system_events.contains(ice::platform::ShardID_WindowMinimized);
+    bool const was_maximized = system_events.contains(ice::platform::ShardID_WindowMaximized);
     ice::vec2i window_size; // unused?
-    bool const was_restored = ice::shards::inspect_last(system_events, ice::platform::ShardID_WindowRestored, window_size);
+    bool const was_restored = system_events.inspect_last(ice::platform::ShardID_WindowRestored, window_size);
 
     // We should never run into a situation where minimizing and restoring happen ad the same time.
     // TODO: Might want to turn this into a state machine.
@@ -747,16 +747,13 @@ auto ice_suspend(
 
     if (runtime.is_exiting)
     {
-        ice::shards::remove_all_of(
-            runtime.frame->shards(),
-            ice::ShardID_WorldActivate
-        );
+        runtime.frame->shards().remove_all_of(ice::ShardID_WorldActivate);
 
         ice::Array<ice::StringID> worlds{ state.alloc };
         state.engine->worlds().query_worlds(worlds);
         for (ice::StringID_Arg world : worlds)
         {
-            ice::shards::push_back(runtime.frame->shards(), ice::ShardID_WorldDeactivate | ice::stringid_hash(world));
+            runtime.frame->shards().push_back(ice::ShardID_WorldDeactivate | ice::stringid_hash(world));
         }
 
         // Apply state events so we can already get the events for the next frame

source/code/iceshard/engine/private/action/action_system.cxx

@@ -172,7 +172,7 @@ namespace ice::action
     ) noexcept
     {
         ice::ShardContainer new_shards{ _step_shards_alloc };
-        ice::shards::reserve(new_shards, 64);
+        new_shards.reserve(64);
 
         for (ActionInstance* const action : _actions)
         {
@@ -208,12 +208,12 @@ namespace ice::action
             if (action->state == ActionState::Active)
             {
                 ice::StringID_Hash action_name = ice::stringid_hash(action->name);
-                ice::shards::push_back(new_shards, ice::action::Shard_ActionEventReset | action_name);
+                new_shards.push_back(ice::action::Shard_ActionEventReset | action_name);
 
                 current_stage = stages + action->current_stage_idx;
                 if (current_stage->stage_shardid != ice::Shard_Invalid)
                 {
-                    ice::shards::push_back(new_shards, ice::shard(current_stage->stage_shardid) | action_name);
+                    new_shards.push_back(ice::shard(current_stage->stage_shardid) | action_name);
                 }
             }
         }
@@ -276,7 +276,7 @@ namespace ice::action
 
                                 if (current_stage->stage_shardid != ice::Shard_Invalid)
                                 {
-                                    ice::shards::push_back(new_shards, ice::shard(current_stage->stage_shardid) | ice::stringid_hash(action->name));
+                                    new_shards.push_back(ice::shard(current_stage->stage_shardid) | ice::stringid_hash(action->name));
                                 }
                             }
                         }
@@ -293,15 +293,15 @@ namespace ice::action
         {
             if (action->state == ActionState::FinishedSuccess)
             {
-                ice::shards::push_back(new_shards, ice::action::Shard_ActionEventSuccess | ice::stringid_hash(action->name));
+                new_shards.push_back(ice::action::Shard_ActionEventSuccess | ice::stringid_hash(action->name));
             }
             else if (action->state == ActionState::FinishedFailure)
             {
-                ice::shards::push_back(new_shards, ice::action::Shard_ActionEventFailed | ice::stringid_hash(action->name));
+                new_shards.push_back(ice::action::Shard_ActionEventFailed | ice::stringid_hash(action->name));
             }
         }
 
-        ice::shards::push_back(shards, new_shards._data);
+        shards.push_back(new_shards);
     }
 
     auto create_action_system(

source/code/iceshard/engine/private/engine_state_tracker_default.cxx

@@ -155,7 +155,7 @@ namespace ice
     {
         ice::StackAllocator<512_B> temp_alloc;
         ice::ShardContainer temp_shards{ temp_alloc };
-        temp_shards._data.reserve(
+        temp_shards.reserve(
             ice::mem_max_capacity(
                 ice::size_of<ice::Shard>,
                 decltype(temp_alloc)::Constant_InternalCapacity
@@ -170,8 +170,8 @@ namespace ice
             if (collect_pending_states(*input_shards))
             {
                 // Push back temporary shards into output shards
-                ice::shards::push_back(out_shards, temp_shards._data);
-                ice::shards::clear(temp_shards);
+                out_shards.push_back(temp_shards);
+                temp_shards.clear();
 
                 // Commit the new states and gather the new shards
                 _pending_states.for_each([&temp_shards](EngineStatePending const& pending) noexcept
@@ -200,17 +200,17 @@ namespace ice
             else
             {
                 // Output temporary shards since they might trigger other events.
-                ice::shards::push_back(out_shards, temp_shards._data);
+                out_shards.push_back(temp_shards);
 
                 // Clear temporary shards so we can escape the loop normally.
-                ice::shards::clear(temp_shards);
+                temp_shards.clear();
             }
 
             // Set input shards to temp_shards
             input_shards = &temp_shards;
 
             // If we have any shards added, check if we can collect another set of states.
-        } while (ice::shards::empty(temp_shards) == false);
+        } while (temp_shards.not_empty());
 
         return true;
     }
@@ -292,8 +292,7 @@ namespace ice
     {
         for (ice::EngineStateTrigger const& trigger : _available_triggers)
         {
-            ice::shards::for_each(
-                shards,
+            shards.for_each(
                 trigger.when,
                 [&](ice::Shard shard) noexcept
                 {

source/code/iceshard/engine/private/engine_state_tracker_default.hxx

@@ -5,7 +5,7 @@
 #include <ice/engine_state_tracker.hxx>
 #include <ice/array.hxx>
 #include <ice/queue.hxx>
-#include <ice/hashmap.hxx>
+#include <ice/multi_hashmap.hxx>
 #include <ice/mem_allocator_stack.hxx>
 #include <ice/log.hxx>
 

source/code/iceshard/iceshard/private/iceshard_frame.cxx

@@ -124,7 +124,7 @@ namespace ice
 
     auto IceshardEngineFrame::extract_tasks() noexcept -> ice::Array<ice::Task<>>
     {
-        return  ice::Array<ice::Task<>>{ *_shards._data._allocator };
+        return  ice::Array<ice::Task<>>{ *_shards._allocator };
     }
 
     auto create_iceshard_frame(

source/code/iceshard/iceshard/private/iceshard_runner.cxx

@@ -215,7 +215,7 @@ namespace ice
         if (trigger.to == State_WorldRuntimeActive)
         {
             ice::wait_for(world->activate(params));
-            ice::shards::push_back(out_shards, trigger.results | world_name.value);
+            out_shards.push_back(trigger.results | world_name.value);
         }
         else if (trigger.to == State_WorldRuntimeInactive)
         {

source/code/iceshard/iceshard/private/iceshard_trait_context.cxx

@@ -76,7 +76,7 @@ namespace ice
         // Push shards into the out container. (ice::detail::TraitEvent decays into ice::Shard)
         for (ice::Shard shard : _events_expired)
         {
-            ice::shards::push_back(out_shards, shard);
+            out_shards.push_back(shard);
         }
     }
 

source/code/iceshard/iceshard/private/iceshard_world.cxx

@@ -41,7 +41,7 @@ namespace ice
 
         if (_devui != nullptr && _devui->world_operation != ice::Shard_Invalid)
         {
-            ice::shards::push_back(out_shards, ice::exchange(_devui->world_operation, ice::Shard_Invalid));
+            out_shards.push_back(ice::exchange(_devui->world_operation, ice::Shard_Invalid));
         }
     }
 

source/code/iceshard/iceshard/private/iceshard_world_manager.cxx

@@ -45,7 +45,7 @@ namespace ice
         ) noexcept -> ice::Task<>
         {
             co_await task;
-            ice::shards::push_back(out_shards, shard);
+            out_shards.push_back(shard);
         }
 
     } // namespace detail
@@ -147,8 +147,7 @@ namespace ice
         Entry world_entry{ .context = ice::move(world_context), .world = world };
 
         // Add a new pending event
-        ice::shards::push_back(
-            _pending_events,
+        _pending_events.push_back(
             ice::ShardID_WorldCreated | ice::stringid_hash(world_template.name)
         );
 
@@ -178,8 +177,7 @@ namespace ice
         );
 
         // Add a new pending event
-        ice::shards::push_back(
-            _pending_events,
+        _pending_events.push_back(
             ice::ShardID_WorldDestroyed | ice::stringid_hash(name)
         );
 
@@ -199,8 +197,8 @@ namespace ice
 
     void IceshardWorldManager::query_pending_events(ice::ShardContainer& out_events) noexcept
     {
-        ice::shards::push_back(out_events, _pending_events._data);
-        ice::shards::clear(_pending_events);
+        out_events.push_back(_pending_events);
+        _pending_events.clear();
     }
 
     void IceshardWorldManager::pre_update(
@@ -260,7 +258,7 @@ namespace ice
 
             if (trigger.results != ice::Shard_Invalid)
             {
-                ice::shards::push_back(out_shards, trigger.results | world_name);
+                out_shards.push_back(trigger.results | world_name);
             }
         }