#ICE-206 Work Type Refactor

(#ICE-203, #ICE-204, #ICE-205, #ICE-206)
Required changes after initial refactor of the 'Span' type.

Author: Dandielo

source/code/core/tasks/private/internal_tasks/task_utils.hxx

@@ -111,13 +111,13 @@ namespace ice
             constexpr auto await_ready() const noexcept
             {
                 // Only suspend if we actually have tasks
-                return ice::span::empty(tasks);
+                return tasks.is_empty();
             }
 
             inline auto await_suspend(std::coroutine_handle<> coro) noexcept
             {
                 // Set the 'running' variable so we can track how many tasks arleady finished.
-                running.store(ice::count(tasks) + 1, std::memory_order_relaxed);
+                running.store(tasks.size().u32() + 1, std::memory_order_relaxed);
 
                 for (ice::Task<void>& task : tasks)
                 {
@@ -132,7 +132,7 @@ namespace ice
             constexpr bool await_resume() const noexcept
             {
                 ICE_ASSERT_CORE(running.load(std::memory_order_relaxed) == 0);
-                return ice::span::any(tasks);
+                return tasks.not_empty();
             }
         };
         return Awaitable{ tasks };
@@ -149,13 +149,13 @@ namespace ice
             constexpr auto await_ready() const noexcept
             {
                 // Only suspend if we actually have tasks
-                return ice::span::empty(tasks);
+                return tasks.is_empty();
             }
 
             inline auto await_suspend(std::coroutine_handle<> coro) noexcept
             {
                 // Set the 'running' variable so we can track how many tasks arleady finished.
-                running.store(ice::count(tasks) + 1, std::memory_order_relaxed);
+                running.store(tasks.size().u32() + 1, std::memory_order_relaxed);
 
                 for (ice::Task<>& task : tasks)
                 {
@@ -170,7 +170,7 @@ namespace ice
             constexpr bool await_resume() const noexcept
             {
                 ICE_ASSERT_CORE(running.load(std::memory_order_relaxed) == 0);
-                return ice::span::any(tasks);
+                return tasks.not_empty();
             }
         };
         return Awaitable{ tasks, scheduler };

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

@@ -81,7 +81,7 @@ namespace ice
         {
             ice::execute_detached_task(ice::move(task));
         }
-        return ice::span::any(tasks);
+        return tasks.not_empty();
     }
 
     bool schedule_task(ice::Task<> task, ice::TaskScheduler& scheduler) noexcept
@@ -100,7 +100,7 @@ namespace ice
         {
             ice::schedule_detached_task(ice::move(task), scheduler);
         }
-        return ice::span::any(tasks);
+        return tasks.not_empty();
     }
 
     bool schedule_queue(ice::TaskQueue& queue, ice::TaskScheduler& scheduler) noexcept

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

@@ -86,7 +86,7 @@ namespace ice
 
     auto ice::ConfigBuilderValue::operator[](ice::String key) noexcept -> ConfigBuilderValue
     {
-        ICE_ASSERT_CORE(key.find_first_of('.') == ice::none_index);
+        ICE_ASSERT_CORE(key.find_first_of('.') == ice::nindex_none);
 
         ConfigBuilderEntry* const entry = _idx == ice::u32_max
             ? _internal : (static_cast<ConfigBuilderContainer*>(_internal)->_entries._data + _idx);

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

@@ -132,7 +132,7 @@ namespace ice::config::detail
 
         // If this key has multiple parts recursively enter config search
         ice::nindex key_split_location = key.find_first_of({".|"});
-        while (key_split_location != ice::none_index && result)
+        while (key_split_location != ice::nindex_none && result)
         {
             bool const is_table = finalcfg._keys->type != CONFIG_KEYTYPE_STRING;
             ice::String const keyval = key.substr(0, key_split_location);

source/code/core/utils/private/native_file.cxx

@@ -444,7 +444,7 @@ namespace ice::native_file
             {
                 // Remove the top-most the directory explicitly.
                 ice::nindex const dirslash = dirpath.find_last_of(L"\\/");
-                if (dirslash == ice::none_index)
+                if (dirslash == ice::nindex_none)
                 {
                     return false;
                 }
@@ -794,7 +794,7 @@ namespace ice::native_file
             {
                 // Remove the top-most the directory explicitly.
                 ice::nindex const dirslash = ice::string::find_last_of(dirpath, ice::String{ "/" });
-                if (dirslash == ice::none_index)
+                if (dirslash == ice::nindex_none)
                 {
                     return false;
                 }

source/code/core/utils/private/path_utils.cxx

@@ -30,7 +30,7 @@ namespace ice::path
             {
                 if (path.size() >= 3)
                 {
-                    return path[1] == Separators_Drive<CharType>[0] && Separators_Directory<CharType>.find_first_of(path[2]) != ice::none_index;
+                    return path[1] == Separators_Drive<CharType>[0] && Separators_Directory<CharType>.find_first_of(path[2]) != ice::nindex_none;
                 }
                 return false;
             }
@@ -48,7 +48,7 @@ namespace ice::path
                 // Only support single-letter drives
                 return path.size() == 3
                     && path[1] == Separators_Drive<CharType>[0]
-                    && path.find_first_of(Separators_Directory<CharType>, path[2]) != ice::none_index;
+                    && path.find_first_of(Separators_Directory<CharType>, path[2]) != ice::nindex_none;
             }
             else
             {
@@ -82,7 +82,7 @@ namespace ice::path
         constexpr auto directory(ice::BasicString<CharType> str) noexcept -> ice::BasicString<CharType>
         {
             ice::nindex const separator_pos = str.find_last_of(Separators_Directory<CharType>);
-            if (separator_pos == ice::none_index)
+            if (separator_pos == ice::nindex_none)
             {
                 return str.substr(str.size(), separator_pos);
             }
@@ -178,7 +178,7 @@ namespace ice::path
             it = beg;
 
             ice::nindex const begin = path.find_first_of(Separators_Drive<CharType>);
-            if (begin != ice::none_index)
+            if (begin != ice::nindex_none)
             {
                 it = it + begin + 1;
             }
@@ -222,7 +222,7 @@ namespace ice::path
         auto replace_filename(ice::HeapString<CharType>& str, ice::BasicString<CharType> name) noexcept -> ice::BasicString<CharType>
         {
             auto const separator_pos = str.find_last_of(Separators_Directory<CharType>);
-            if (separator_pos != ice::none_index)
+            if (separator_pos != ice::nindex_none)
             {
                 str.resize(separator_pos + 1);
             }
@@ -239,7 +239,7 @@ namespace ice::path
         auto replace_extension(ice::HeapString<CharType>& str, ice::BasicString<CharType> extension) noexcept -> ice::BasicString<CharType>
         {
             auto const separator_pos = str.find_last_of(Separators_Dot<CharType>[0]);
-            if (separator_pos != ice::none_index)
+            if (separator_pos != ice::nindex_none)
             {
                 str.resize(separator_pos);
             }

source/code/framework/framework_base/private/asset/tilemap/asset_tilemap_oven_tmx.cxx

@@ -144,7 +144,7 @@ namespace ice
 
         ice::nindex beg = 0;
         ice::nindex end = csv_data.find_first_of(',');
-        while (end != ice::none_index)
+        while (end != ice::nindex_none)
         {
             char const* val_beg = csv_data.begin() + beg;
             char const* val_end = csv_data.begin() + end;
@@ -191,7 +191,7 @@ namespace ice
 
         ice::nindex beg = 0;
         ice::nindex end = points.find_first_of(' ');
-        while (end != ice::none_index)
+        while (end != ice::nindex_none)
         {
             char const* val_beg = data + beg;
             char const* val_delim = data + points.find_first_of(',', beg);

source/code/iceshard/engine/private/ecs/ecs_archetype_index.cxx

@@ -36,9 +36,9 @@ namespace ice::ecs
         {
             using QueryTypeInfo = ice::ecs::detail::QueryTypeInfo;
 
-            ice::u32 const tag_count = ice::count(in_required_tags);
-            ice::u32 const condition_count = ice::count(in_conditions);
-            ice::u32 const identifier_count = ice::count(checked_identifiers);
+            ice::u32 const tag_count = in_required_tags.size().u32();
+            ice::u32 const condition_count = in_conditions.size().u32();
+            ice::u32 const identifier_count = checked_identifiers.size().u32();
             ice::u32 const identifier_last_index = identifier_count - 1;
 
             ice::u32 tag_idx = 0;
@@ -121,7 +121,7 @@ namespace ice::ecs
             ice::usize& offset_values_out
         ) noexcept -> ice::meminfo
         {
-            ice::u32 const component_count = ice::span::count(info.component_identifiers);
+            ice::u32 const component_count = info.component_identifiers.size().u32();
 
             ice::meminfo result = ice::meminfo_of<ArchetypeDataHeader>;
             offset_name_out = result += ice::meminfo_of<ice::utf8> * (name.size() + 1);
@@ -191,7 +191,7 @@ namespace ice::ecs
             data_block_pool = _default_block_pool.get();
         }
 
-        ice::u32 const component_count = ice::count(archetype_info.component_identifiers);
+        ice::u32 const component_count = archetype_info.component_identifiers.size().u32();
 
         ICE_ASSERT(
             component_count >= 2,
@@ -335,12 +335,12 @@ namespace ice::ecs
 
         // We need to skip the first query entry if it's for `ice::ecs::Entity`
         // This is due to the fact that it's always there and is not taken into account when sorting components by identifiers.
-        if (ice::span::front(query_info).identifier == ice::ecs::Constant_ComponentIdentifier<ice::ecs::Entity>)
+        if (query_info.first().identifier == ice::ecs::Constant_ComponentIdentifier<ice::ecs::Entity>)
         {
-            query_info = ice::span::subspan(query_info, 1);
+            query_info = query_info.subspan(1);
         }
 
-        ice::u32 const required_tag_count = ice::count(query_tags);
+        ice::u32 const required_tag_count = query_tags.size().u32();
         ice::u32 const required_component_count = [](auto const& query_conditions) noexcept -> ice::u32
         {
             ice::u32 result = 0;
@@ -362,7 +362,7 @@ namespace ice::ecs
         {
             ice::ecs::detail::ArchetypeInstanceInfo const& archetype_info = entry->archetype_info;
 
-            ice::u32 const archetype_component_count = ice::count(archetype_info.component_identifiers);
+            ice::u32 const archetype_component_count = archetype_info.component_identifiers.size().u32();
             if (archetype_component_count < total_required_type_count)
             {
                 continue;
@@ -389,7 +389,7 @@ namespace ice::ecs
     ) const noexcept
     {
         ICE_ASSERT(
-            ice::count(archetypes) == ice::count(out_instance_infos),
+            archetypes.size() == out_instance_infos.size(),
             "Archetype instance fetch called with different input and output array sizes."
         );
 
@@ -417,7 +417,7 @@ namespace ice::ecs
     ) const noexcept
     {
         ICE_ASSERT(
-            ice::count(archetype_instances) == ice::count(out_instance_infos),
+            archetype_instances.size() == out_instance_infos.size(),
             "Archetype instance fetch called with different input and output array sizes."
         );
 

source/code/iceshard/engine/private/ecs/ecs_entity_index.cxx

@@ -96,7 +96,7 @@ namespace ice::ecs
         {
             ice::u32 const indices_taken = ice::queue::take_front(
                 _free_indices,
-                ice::span::subspan(ice::Span{indices}, 0, ice::min<ice::u32>(free_count, ice::count(indices)))
+                ice::Span{ indices }.headspan(free_count)
             );
 
             for (ice::u32 idx = 0; idx < indices_taken; ++idx)
@@ -110,7 +110,7 @@ namespace ice::ecs
         }
 
         ice::u32 gen_index = ice::array::count(_generation);
-        ice::u32 const missing_entities = ice::count(out_entities) - total_indices_taken;
+        ice::u32 const missing_entities = out_entities.size().u32() - total_indices_taken;
         ice::u32 const final_index = gen_index + missing_entities;
 
         if (final_index > 0)

source/code/iceshard/engine/private/ecs/ecs_entity_operations.cxx

@@ -297,16 +297,16 @@ namespace ice::ecs
 
     void EntityOperations::destroy(ice::Span<ice::ecs::Entity const> entities) noexcept
     {
-        if (ice::span::empty(entities))
+        if (entities.is_empty())
         {
             return;
         }
 
         void* handle_loc;
-        EntityOperation* operation = new_storage_operation(ice::meminfo_of<ice::ecs::Entity> * ice::count(entities), handle_loc);
+        EntityOperation* operation = new_storage_operation(ice::meminfo_of<ice::ecs::Entity> * entities.size().u32(), handle_loc);
         operation->archetype = ice::ecs::Archetype::Invalid;
         operation->entities = reinterpret_cast<ice::ecs::Entity*>(handle_loc);
-        operation->entity_count = ice::count(entities);
+        operation->entity_count = entities.size().u32();
         operation->component_data = nullptr;
         operation->component_data_size = 0;
 
@@ -318,13 +318,13 @@ namespace ice::ecs
         ice::Span<ice::Data const> component_data
     ) noexcept -> Result
     {
-        if (ice::span::empty(entities) || (mode == 2 && index_create_count == 0) || mode == 0)
+        if (entities.is_empty() || (mode == 2 && index_create_count == 0) || mode == 0)
         {
             return Result{ *this };
         }
 
-        ice::u32 const entity_count = mode == 2 ? index_create_count : ice::count(entities);
-        ice::u32 const component_count = ice::count(component_info.names);
+        ice::u32 const entity_count = mode == 2 ? index_create_count : entities.size().u32();
+        ice::u32 const component_count = component_info.names.size().u32();
 
         ice::meminfo additional_data_size = ice::meminfo{ filter_data_size, ice::ualign::b_8 };
         additional_data_size += ice::meminfo_of<ice::ecs::Entity> * entity_count;
@@ -424,7 +424,7 @@ namespace ice::ecs
     {
         if (mode != 0)
         {
-            ice::u32 const entity_count = mode == 2 ? index_create_count : ice::count(entities);
+            ice::u32 const entity_count = mode == 2 ? index_create_count : entities.size().u32();
 
             ice::meminfo required_memory = ice::meminfo{ filter_data_size, ice::ualign::b_8 };
             required_memory += ice::meminfo_of<ice::ecs::Entity> * entity_count;