#ICE-206

Dandielo · Dandielo · commit 7c3944793f41 · 2026-01-09T23:02:45.000+09:00
Fixing all code locations affected by the api change of 'Span'.
diff --git a/source/code/core/collections/public/ice/container/array.hxx b/source/code/core/collections/public/ice/container/array.hxx
@@ -74,8 +74,6 @@ namespace ice::array
     template<typename Type, ice::ContainerLogic Logic>
     inline auto back(ice::Array<Type, Logic>& arr) noexcept -> Type&;
 
-
-
     template<typename Type, ice::ContainerLogic Logic>
     inline auto count(ice::Array<Type, Logic> const& arr) noexcept -> ice::u32;
 
diff --git a/source/code/core/collections/public/ice/container/impl/array_impl.inl b/source/code/core/collections/public/ice/container/impl/array_impl.inl
@@ -83,13 +83,13 @@ namespace ice
             {
                 ice::mem_copy_construct_n_at(
                     ice::array::memory(*this),
-                    ice::span::data(values),
+                    values.data(),
                     values.size()
                 );
             }
             else
             {
-                ice::memcpy(_data, ice::span::data(values), ice::span::size_bytes(values));
+                ice::memcpy(_data, values.data(), values.size().bytes());
             }
 
             _count = values.size().u32();
@@ -362,15 +362,15 @@ namespace ice
             {
                 ice::mem_copy_construct_n_at<Type>(
                     Memory{ .location = arr._data + arr._count, .size = ice::size_of<Type> * missing_items, .alignment = ice::align_of<Type> },
-                    ice::span::data(items),
+                    items.data(),
                     items.size().u32()
                 );
             }
             else
             {
                 ice::memcpy(
                     Memory{ .location = arr._data + arr._count, .size = ice::size_of<Type> * missing_items, .alignment = ice::align_of<Type> },
-                    ice::span::data_view(items)
+                    items.data_view()
                 );
             }
 
diff --git a/source/code/core/collections/public/ice/container/impl/queue_impl.inl b/source/code/core/collections/public/ice/container/impl/queue_impl.inl
@@ -461,7 +461,7 @@ namespace ice
                         .size = ice::size_of<Type> * head_space,
                         .alignment = ice::align_of<Type>
                     },
-                    ice::span::data(items),
+                    items.data(),
                     head_space
                 );
                 ice::mem_copy_construct_n_at<Type>(
@@ -470,7 +470,7 @@ namespace ice
                         .size = ice::size_of<Type> * tail_space,
                         .alignment = ice::align_of<Type>
                     },
-                    ice::span::data(items) + head_space,
+                    items.data() + head_space,
                     tail_space
                 );
             }
@@ -483,7 +483,7 @@ namespace ice
                         .alignment = ice::align_of<Type>
                     },
                     Data{
-                        .location = ice::span::data(items),
+                        .location = items.data(),
                         .size = ice::size_of<Type> * head_space,
                         .alignment = ice::align_of<Type>
                     }
@@ -495,7 +495,7 @@ namespace ice
                         .alignment = ice::align_of<Type>
                     },
                     Data{
-                        .location = ice::span::data(items) + head_space,
+                        .location = items.data() + head_space,
                         .size = ice::size_of<Type> * tail_space,
                         .alignment = ice::align_of<Type>
                     }
@@ -605,13 +605,13 @@ namespace ice
 
             if constexpr (Logic == ContainerLogic::Complex)
             {
-                ice::mem_move_n_to(ice::span::begin(out_values), queue._data + queue._offset, first_part_count);
-                ice::mem_move_n_to(ice::span::begin(out_values) + first_part_count, queue._data, second_part);
+                ice::mem_move_n_to(out_values.begin(), queue._data + queue._offset, first_part_count);
+                ice::mem_move_n_to(out_values.begin() + first_part_count, queue._data, second_part);
             }
             else
             {
-                ice::memcpy(ice::span::begin(out_values), queue._data + queue._offset, first_part_count * sizeof(Type));
-                ice::memcpy(ice::span::begin(out_values) + first_part_count, queue._data, second_part * sizeof(Type));
+                ice::memcpy(out_values.begin(), queue._data + queue._offset, first_part_count * sizeof(Type));
+                ice::memcpy(out_values.begin() + first_part_count, queue._data, second_part * sizeof(Type));
             }
 
             ice::queue::pop_front(queue, taken_items);
diff --git a/source/code/core/collections/public/ice/sort.hxx b/source/code/core/collections/public/ice/sort.hxx
@@ -67,25 +67,25 @@ namespace ice
     template<typename T, typename U> requires (std::convertible_to<T, U>)
     constexpr auto lower_bound(ice::Span<T> values, U const& value) noexcept -> ice::u32
     {
-        return static_cast<ice::u32>(std::lower_bound(ice::span::begin(values), ice::span::end(values), value) - ice::span::begin(values));
+        return static_cast<ice::u32>(std::lower_bound(values.begin(), values.end(), value) - values.begin());
     }
 
     template<typename T, typename Comp, typename U> requires (std::convertible_to<T, U>)
     constexpr auto lower_bound(ice::Span<T> values, U const& value, Comp&& comp) noexcept -> ice::u32
     {
-        return static_cast<ice::u32>(std::lower_bound(ice::span::begin(values), ice::span::end(values), value, ice::forward<Comp>(comp)) - ice::span::begin(values));
+        return static_cast<ice::u32>(std::lower_bound(values.begin(), values.end(), value, ice::forward<Comp>(comp)) - values.begin());
     }
 
     template<typename T, typename U> requires (std::convertible_to<T, U>)
     constexpr auto upper_bound(ice::Span<T> values, U const& value) noexcept -> ice::u32
     {
-        return static_cast<ice::u32>(std::upper_bound(ice::span::begin(values), ice::span::end(values), value) - ice::span::begin(values));
+        return static_cast<ice::u32>(std::upper_bound(values.begin(), values.end(), value) - values.begin());
     }
 
     template<typename T, typename Comp, typename U> requires (std::convertible_to<T, U>)
     constexpr auto upper_bound(ice::Span<T> values, U const& value, Comp&& comp) noexcept -> ice::u32
     {
-        return static_cast<ice::u32>(std::upper_bound(ice::span::begin(values), ice::span::end(values), value, ice::forward<Comp>(comp)) - ice::span::begin(values));
+        return static_cast<ice::u32>(std::upper_bound(values.begin(), values.end(), value, ice::forward<Comp>(comp)) - values.begin());
     }
 
     template<typename T, typename U> requires (std::convertible_to<T, U>)
@@ -274,7 +274,7 @@ namespace ice
     template<typename T, typename Pred>
     inline void sort(ice::Span<T> span, Pred&& pred) noexcept
     {
-        std::sort(ice::span::begin(span), ice::span::end(span), ice::forward<Pred>(pred));
+        std::sort(span.begin(), span.end(), ice::forward<Pred>(pred));
     }
 
     template<typename K, typename V, typename Pred>
diff --git a/source/code/core/collections/tests/test_data_memory.cxx b/source/code/core/collections/tests/test_data_memory.cxx
@@ -48,8 +48,8 @@ SCENARIO("ice :: Data")
 
         data = ice::data_view(values_span);
 
-        CHECK(data.location == ice::span::data(values_span));
-        CHECK(data.size == ice::span::size_bytes(values_span));
-        CHECK(data.alignment == ice::span::alignment(values_span));
+        CHECK(data.location == values_span.data());
+        CHECK(data.size == values_span.size());
+        CHECK(data.alignment == ice::align_of<ice::Span<ice::u64 const>::ValueType>);
     }
 }
diff --git a/source/code/core/memsys/private/mem.cxx b/source/code/core/memsys/private/mem.cxx
@@ -94,6 +94,11 @@ namespace ice
         return std::memcpy(dest, source, size.value);
     }
 
+    auto memcpy(void* dest, ice::Data source) noexcept -> void*
+    {
+        return std::memcpy(dest, source.location, source.size.value);
+    }
+
     auto memcpy(ice::Memory memory, ice::Data data) noexcept -> ice::Memory
     {
         ICE_ASSERT_CORE(memory.alignment >= data.alignment);
diff --git a/source/code/core/memsys/public/ice/mem.hxx b/source/code/core/memsys/public/ice/mem.hxx
@@ -39,7 +39,9 @@ namespace ice
     void release_aligned(void* pointer) noexcept;
 
     auto memcpy(void* dest, void const* source, ice::usize size) noexcept -> void*;
+    auto memcpy(void* dest, ice::Data source) noexcept -> void*;
     auto memcpy(ice::Memory memory, ice::Data data) noexcept -> ice::Memory;
+
     auto memset(ice::Memory memory, ice::u8 value) noexcept -> ice::Memory;
 
     constexpr AllocRequest::AllocRequest(ice::usize size, ice::ualign alignment) noexcept
diff --git a/source/code/core/memsys/public/ice/mem_initializers.hxx b/source/code/core/memsys/public/ice/mem_initializers.hxx
@@ -30,45 +30,45 @@ namespace ice
     }
 
     template<typename T>
-    auto mem_construct_n_at(ice::Memory memory, ice::u32 count) noexcept -> T*
+    auto mem_construct_n_at(ice::Memory memory, ice::u64 count) noexcept -> T*
     {
         // TODO: Assert (align + size)
         T* target_mem = reinterpret_cast<T*>(memory.location);
-        for (ice::u32 idx = 0; idx < count; ++idx)
+        for (ice::u64 idx = 0; idx < count; ++idx)
         {
             new (target_mem + idx) T{ };
         }
         return target_mem;
     }
 
     template<typename T>
-    auto mem_move_construct_n_at(ice::Memory memory, T* objects, ice::u32 count) noexcept -> T*
+    auto mem_move_construct_n_at(ice::Memory memory, T* objects, ice::u64 count) noexcept -> T*
     {
         // TODO: Assert (align + size)
         T* target_mem = reinterpret_cast<T*>(memory.location);
-        for (ice::u32 idx = 0; idx < count; ++idx)
+        for (ice::u64 idx = 0; idx < count; ++idx)
         {
             new (target_mem + idx) T{ ice::move(objects[idx]) };
         }
         return target_mem;
     }
 
     template<typename T>
-    auto mem_move_n_to(T* target_objects, T* objects, ice::u32 count) noexcept -> T*
+    auto mem_move_n_to(T* target_objects, T* objects, ice::u64 count) noexcept -> T*
     {
-        for (ice::u32 idx = 0; idx < count; ++idx)
+        for (ice::u64 idx = 0; idx < count; ++idx)
         {
             target_objects[idx] = ice::move(objects[idx]);
         }
         return target_objects;
     }
 
     template<typename T>
-    auto mem_copy_construct_n_at(ice::Memory memory, T const* objects, ice::u32 count) noexcept -> T*
+    auto mem_copy_construct_n_at(ice::Memory memory, T const* objects, ice::u64 count) noexcept -> T*
     {
         // TODO: Assert (align + size)
         T* target_mem = reinterpret_cast<T*>(memory.location);
-        for (ice::u32 idx = 0; idx < count; ++idx)
+        for (ice::u64 idx = 0; idx < count; ++idx)
         {
             new (target_mem + idx) T{ objects[idx] };
         }
@@ -84,9 +84,9 @@ namespace ice
     }
 
     template<typename T>
-    void mem_destruct_n_at(T* location, ice::u32 count) noexcept
+    void mem_destruct_n_at(T* location, ice::u64 count) noexcept
     {
-        for (ice::u32 idx = 0; idx < count; ++idx)
+        for (ice::u64 idx = 0; idx < count; ++idx)
         {
             ice::mem_destruct_at(location + idx);
         }
diff --git a/source/code/core/utils/public/ice/algorithm.hxx b/source/code/core/utils/public/ice/algorithm.hxx
@@ -11,7 +11,7 @@ namespace ice
     template<typename T, typename U = T>
     constexpr auto accumulate(ice::Span<T const> range, U val) noexcept
     {
-        return ::std::accumulate(ice::begin(range), ice::end(range), val);
+        return ::std::accumulate(range.begin(), range.end(), val);
     }
 
 } // namespace ice
diff --git a/source/code/iceshard/engine/private/ecs/ecs_archetype_index.cxx b/source/code/iceshard/engine/private/ecs/ecs_archetype_index.cxx
@@ -230,20 +230,20 @@ namespace ice::ecs
             ice::memcpy(mem_archetype_name, archetype_info.name.data_view());
 
             // Copy the component idnetifiers
-            ice::memcpy(mem_component_data, ice::span::data_view(archetype_info.component_identifiers));
+            ice::memcpy(mem_component_data, archetype_info.component_identifiers.data_view());
             component_identifiers = reinterpret_cast<ice::StringID const*>(mem_component_data.location);
 
             // Calculate where we start storing the u32 values...
             mem_component_data = ice::ptr_add(result, offset_values);
 
             // Copy the size and alignment.
             component_sizes = reinterpret_cast<ice::u32 const*>(mem_component_data.location);
-            ice::memcpy(mem_component_data, ice::span::data_view(archetype_info.component_sizes));
-            mem_component_data = ice::ptr_add(mem_component_data, ice::span::size_bytes(archetype_info.component_sizes));
+            ice::memcpy(mem_component_data, archetype_info.component_sizes.data_view());
+            mem_component_data = ice::ptr_add(mem_component_data, archetype_info.component_sizes.size());
 
             component_alignments = reinterpret_cast<ice::u32 const*>(mem_component_data.location);
-            ice::memcpy(mem_component_data, ice::span::data_view(archetype_info.component_alignments));
-            mem_component_data = ice::ptr_add(mem_component_data, ice::span::size_bytes(archetype_info.component_alignments));
+            ice::memcpy(mem_component_data, archetype_info.component_alignments.data_view());
+            mem_component_data = ice::ptr_add(mem_component_data, archetype_info.component_alignments.size());
 
             // Save location to store calculated offsets
             component_offsets = reinterpret_cast<ice::u32*>(mem_component_data.location);
diff --git a/source/code/iceshard/engine/private/ecs/ecs_entity_index.cxx b/source/code/iceshard/engine/private/ecs/ecs_entity_index.cxx
@@ -88,7 +88,7 @@ namespace ice::ecs
     bool EntityIndex::create_many(ice::Span<ice::ecs::Entity> out_entities) noexcept
     {
         ice::u32 total_indices_taken = 0;
-        auto out_it = ice::span::begin(out_entities);
+        auto out_it = out_entities.begin();
 
         ice::u32 indices[256];
         ice::i32 free_count = ice::i32(ice::queue::count(_free_indices)) - ice::ecs::Constant_MinimumFreeIndicesBeforeReuse;
diff --git a/source/code/iceshard/engine/private/ecs/ecs_entity_operations.cxx b/source/code/iceshard/engine/private/ecs/ecs_entity_operations.cxx
@@ -310,7 +310,7 @@ namespace ice::ecs
         operation->component_data = nullptr;
         operation->component_data_size = 0;
 
-        ice::memcpy(operation->entities, ice::span::data(entities), ice::span::size_bytes(entities));
+        ice::memcpy(operation->entities, entities.data_view());
     }
 
     auto OperationBuilder::with_data(
@@ -331,9 +331,9 @@ namespace ice::ecs
 
         // Data for storing component info
         additional_data_size += ice::meminfo_of<ice::ecs::OperationComponentInfo>;
-        additional_data_size.size += ice::span::size_bytes(component_info.names);
-        additional_data_size.size += ice::span::size_bytes(component_info.sizes);
-        additional_data_size.size += ice::span::size_bytes(component_info.offsets);
+        additional_data_size.size += component_info.names.size().bytes();
+        additional_data_size.size += component_info.sizes.size().bytes();
+        additional_data_size.size += component_info.offsets.size().bytes();
 
         // Component data
         for (ice::Data const& data : component_data)
@@ -354,7 +354,7 @@ namespace ice::ecs
         ice::ecs::Entity* entities_ptr = reinterpret_cast<ice::ecs::Entity*>(operation_data);
         if (mode == 1)
         {
-            ice::memcpy(entities_ptr, ice::span::data(entities), ice::span::size_bytes(entities));
+            ice::memcpy(entities_ptr, entities.data_view());
         }
         else
         {
@@ -364,10 +364,10 @@ namespace ice::ecs
 
         // Set component info object
         ice::StringID* names_ptr = reinterpret_cast<ice::StringID*>(entities_ptr + entity_count);
-        ice::memcpy(names_ptr, ice::span::data(component_info.names), ice::span::size_bytes(component_info.names));
+        ice::memcpy(names_ptr, component_info.names.data_view());
 
         ice::u32* sizes_ptr = reinterpret_cast<ice::u32*>(names_ptr + component_count);
-        ice::memcpy(sizes_ptr, ice::span::data(component_info.sizes), ice::span::size_bytes(component_info.sizes));
+        ice::memcpy(sizes_ptr, component_info.sizes.data_view());
 
         ice::u32* offsets_ptr = reinterpret_cast<ice::u32*>(sizes_ptr + component_count);
 
@@ -439,7 +439,7 @@ namespace ice::ecs
             ice::ecs::Entity* entities_ptr = reinterpret_cast<ice::ecs::Entity*>(operation_data);
             if (mode == 1)
             {
-                ice::memcpy(entities_ptr, ice::span::data(entities), ice::span::size_bytes(entities));
+                ice::memcpy(entities_ptr, entities.data_view());
             }
             else
             {
@@ -455,7 +455,7 @@ namespace ice::ecs
             operation->filter_data = filter_ptr;
 
             ice::memcpy(operation_data, filter_data, filter_data_size);
-            ice::memcpy(operation->entities, ice::span::data(entities), ice::span::size_bytes(entities));
+            ice::memcpy(operation->entities, entities.data_view());
 
             if (mode == 2)
             {
diff --git a/source/code/iceshard/engine/private/ecs/ecs_entity_storage.cxx b/source/code/iceshard/engine/private/ecs/ecs_entity_storage.cxx
@@ -322,8 +322,8 @@ namespace ice::ecs
             ice::Span<ice::ecs::detail::DataBlock*> data_blocks
         ) noexcept
         {
-            auto const* it = ice::span::begin(entities_to_remove);
-            auto const* const end = ice::span::end(entities_to_remove);
+            auto const* it = entities_to_remove.begin();
+            auto const* const end = entities_to_remove.end();
 
             ArchetypeInstance archetype{};
             ArchetypeInstanceInfo const* archetype_infos[1]{ nullptr };
diff --git a/source/code/iceshard/engine/public/ice/ecs/ecs_archetype.hxx b/source/code/iceshard/engine/public/ice/ecs/ecs_archetype.hxx
@@ -110,7 +110,7 @@ namespace ice::ecs
             component_alignments[idx] = sorted_components[idx - 1].alignment;
         }
 
-        identifier = ice::ecs::detail::make_archetype_identifier(ice::span::from_std_const(component_identifiers));
+        identifier = ice::ecs::detail::make_archetype_identifier(ice::make_span(component_identifiers));
     }
 
     template<ice::ecs::Component... Components>
@@ -125,9 +125,9 @@ namespace ice::ecs
     ) noexcept
         : name{ archetype_info.name }
         , identifier{ archetype_info.identifier }
-        , component_identifiers{ ice::span::from_std_const(archetype_info.component_identifiers) }
-        , component_sizes{ ice::span::from_std_const(archetype_info.component_sizes) }
-        , component_alignments{ ice::span::from_std_const(archetype_info.component_alignments) }
+        , component_identifiers{ ice::make_span(archetype_info.component_identifiers) }
+        , component_sizes{ ice::make_span(archetype_info.component_sizes) }
+        , component_alignments{ ice::make_span(archetype_info.component_alignments) }
     {
     }
 
diff --git a/source/code/iceshard/engine/public/ice/ecs/ecs_entity_operations.hxx b/source/code/iceshard/engine/public/ice/ecs/ecs_entity_operations.hxx
diff --git a/source/code/iceshard/engine/public/ice/ecs/ecs_query_provider.hxx b/source/code/iceshard/engine/public/ice/ecs/ecs_query_provider.hxx
diff --git a/source/code/iceshard/engine/public/ice/ecs/ecs_query_storage_entry.hxx b/source/code/iceshard/engine/public/ice/ecs/ecs_query_storage_entry.hxx
diff --git a/source/code/iceshard/iceshard/private/iceshard_world_tasks_launcher.cxx b/source/code/iceshard/iceshard/private/iceshard_world_tasks_launcher.cxx
diff --git a/source/code/modules/iceshard_pipelines/private/pipeline_ui/ip_ui_asset.cxx b/source/code/modules/iceshard_pipelines/private/pipeline_ui/ip_ui_asset.cxx
diff --git a/source/code/systems/input_action_system/private/input_action_layer.cxx b/source/code/systems/input_action_system/private/input_action_layer.cxx
diff --git a/source/code/systems/input_action_system/private/input_action_script.cxx b/source/code/systems/input_action_system/private/input_action_script.cxx

Original file line number	Diff line number	Diff line change
`@@ -83,13 +83,13 @@ namespace ice`
`83`	`83`	`{`
`84`	`84`	`ice::mem_copy_construct_n_at(`
`85`	`85`	`ice::array::memory(*this),`
`86`		`- ice::span::data(values),`
	`86`	`+ values.data(),`
`87`	`87`	`values.size()`
`88`	`88`	`);`
`89`	`89`	`}`
`90`	`90`	`else`
`91`	`91`	`{`
`92`		`- ice::memcpy(_data, ice::span::data(values), ice::span::size_bytes(values));`
	`92`	`+ ice::memcpy(_data, values.data(), values.size().bytes());`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`_count = values.size().u32();`
`@@ -362,15 +362,15 @@ namespace ice`
`362`	`362`	`{`
`363`	`363`	`ice::mem_copy_construct_n_at<Type>(`
`364`	`364`	`Memory{ .location = arr._data + arr._count, .size = ice::size_of<Type> * missing_items, .alignment = ice::align_of<Type> },`
`365`		`- ice::span::data(items),`
	`365`	`+ items.data(),`
`366`	`366`	`items.size().u32()`
`367`	`367`	`);`
`368`	`368`	`}`
`369`	`369`	`else`
`370`	`370`	`{`
`371`	`371`	`ice::memcpy(`
`372`	`372`	`Memory{ .location = arr._data + arr._count, .size = ice::size_of<Type> * missing_items, .alignment = ice::align_of<Type> },`
`373`		`- ice::span::data_view(items)`
	`373`	`+ items.data_view()`
`374`	`374`	`);`
`375`	`375`	`}`
`376`	`376`
Original file line number	Diff line number	Diff line change
`@@ -67,25 +67,25 @@ namespace ice`
`67`	`67`	`template<typename T, typename U> requires (std::convertible_to<T, U>)`
`68`	`68`	`constexpr auto lower_bound(ice::Span<T> values, U const& value) noexcept -> ice::u32`
`69`	`69`	`{`
`70`		`- return static_cast<ice::u32>(std::lower_bound(ice::span::begin(values), ice::span::end(values), value) - ice::span::begin(values));`
	`70`	`+ return static_cast<ice::u32>(std::lower_bound(values.begin(), values.end(), value) - values.begin());`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`template<typename T, typename Comp, typename U> requires (std::convertible_to<T, U>)`
`74`	`74`	`constexpr auto lower_bound(ice::Span<T> values, U const& value, Comp&& comp) noexcept -> ice::u32`
`75`	`75`	`{`
`76`		`- return static_cast<ice::u32>(std::lower_bound(ice::span::begin(values), ice::span::end(values), value, ice::forward<Comp>(comp)) - ice::span::begin(values));`
	`76`	`+ return static_cast<ice::u32>(std::lower_bound(values.begin(), values.end(), value, ice::forward<Comp>(comp)) - values.begin());`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`template<typename T, typename U> requires (std::convertible_to<T, U>)`
`80`	`80`	`constexpr auto upper_bound(ice::Span<T> values, U const& value) noexcept -> ice::u32`
`81`	`81`	`{`
`82`		`- return static_cast<ice::u32>(std::upper_bound(ice::span::begin(values), ice::span::end(values), value) - ice::span::begin(values));`
	`82`	`+ return static_cast<ice::u32>(std::upper_bound(values.begin(), values.end(), value) - values.begin());`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`template<typename T, typename Comp, typename U> requires (std::convertible_to<T, U>)`
`86`	`86`	`constexpr auto upper_bound(ice::Span<T> values, U const& value, Comp&& comp) noexcept -> ice::u32`
`87`	`87`	`{`
`88`		`- return static_cast<ice::u32>(std::upper_bound(ice::span::begin(values), ice::span::end(values), value, ice::forward<Comp>(comp)) - ice::span::begin(values));`
	`88`	`+ return static_cast<ice::u32>(std::upper_bound(values.begin(), values.end(), value, ice::forward<Comp>(comp)) - values.begin());`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`template<typename T, typename U> requires (std::convertible_to<T, U>)`
`@@ -274,7 +274,7 @@ namespace ice`
`274`	`274`	`template<typename T, typename Pred>`
`275`	`275`	`inline void sort(ice::Span<T> span, Pred&& pred) noexcept`
`276`	`276`	`{`
`277`		`- std::sort(ice::span::begin(span), ice::span::end(span), ice::forward<Pred>(pred));`
	`277`	`+ std::sort(span.begin(), span.end(), ice::forward<Pred>(pred));`
`278`	`278`	`}`
`279`	`279`
`280`	`280`	`template<typename K, typename V, typename Pred>`
Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,8 @@ SCENARIO("ice :: Data")`
`48`	`48`
`49`	`49`	`data = ice::data_view(values_span);`
`50`	`50`
`51`		`- CHECK(data.location == ice::span::data(values_span));`
`52`		`- CHECK(data.size == ice::span::size_bytes(values_span));`
`53`		`- CHECK(data.alignment == ice::span::alignment(values_span));`
	`51`	`+ CHECK(data.location == values_span.data());`
	`52`	`+ CHECK(data.size == values_span.size());`
	`53`	`+ CHECK(data.alignment == ice::align_of<ice::Span<ice::u64 const>::ValueType>);`
`54`	`54`	`}`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,6 +94,11 @@ namespace ice`
`94`	`94`	`return std::memcpy(dest, source, size.value);`
`95`	`95`	`}`
`96`	`96`
	`97`	`+ auto memcpy(void* dest, ice::Data source) noexcept -> void*`
	`98`	`+ {`
	`99`	`+ return std::memcpy(dest, source.location, source.size.value);`
	`100`	`+ }`
	`101`	`+`
`97`	`102`	`auto memcpy(ice::Memory memory, ice::Data data) noexcept -> ice::Memory`
`98`	`103`	`{`
`99`	`104`	`ICE_ASSERT_CORE(memory.alignment >= data.alignment);`
Original file line number	Diff line number	Diff line change
`@@ -30,45 +30,45 @@ namespace ice`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`template<typename T>`
`33`		`- auto mem_construct_n_at(ice::Memory memory, ice::u32 count) noexcept -> T*`
	`33`	`+ auto mem_construct_n_at(ice::Memory memory, ice::u64 count) noexcept -> T*`
`34`	`34`	`{`
`35`	`35`	`// TODO: Assert (align + size)`
`36`	`36`	`T* target_mem = reinterpret_cast<T*>(memory.location);`
`37`		`- for (ice::u32 idx = 0; idx < count; ++idx)`
	`37`	`+ for (ice::u64 idx = 0; idx < count; ++idx)`
`38`	`38`	`{`
`39`	`39`	`new (target_mem + idx) T{ };`
`40`	`40`	`}`
`41`	`41`	`return target_mem;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`template<typename T>`
`45`		`- auto mem_move_construct_n_at(ice::Memory memory, T* objects, ice::u32 count) noexcept -> T*`
	`45`	`+ auto mem_move_construct_n_at(ice::Memory memory, T* objects, ice::u64 count) noexcept -> T*`
`46`	`46`	`{`
`47`	`47`	`// TODO: Assert (align + size)`
`48`	`48`	`T* target_mem = reinterpret_cast<T*>(memory.location);`
`49`		`- for (ice::u32 idx = 0; idx < count; ++idx)`
	`49`	`+ for (ice::u64 idx = 0; idx < count; ++idx)`
`50`	`50`	`{`
`51`	`51`	`new (target_mem + idx) T{ ice::move(objects[idx]) };`
`52`	`52`	`}`
`53`	`53`	`return target_mem;`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`template<typename T>`
`57`		`- auto mem_move_n_to(T* target_objects, T* objects, ice::u32 count) noexcept -> T*`
	`57`	`+ auto mem_move_n_to(T* target_objects, T* objects, ice::u64 count) noexcept -> T*`
`58`	`58`	`{`
`59`		`- for (ice::u32 idx = 0; idx < count; ++idx)`
	`59`	`+ for (ice::u64 idx = 0; idx < count; ++idx)`
`60`	`60`	`{`
`61`	`61`	`target_objects[idx] = ice::move(objects[idx]);`
`62`	`62`	`}`
`63`	`63`	`return target_objects;`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`template<typename T>`
`67`		`- auto mem_copy_construct_n_at(ice::Memory memory, T const* objects, ice::u32 count) noexcept -> T*`
	`67`	`+ auto mem_copy_construct_n_at(ice::Memory memory, T const* objects, ice::u64 count) noexcept -> T*`
`68`	`68`	`{`
`69`	`69`	`// TODO: Assert (align + size)`
`70`	`70`	`T* target_mem = reinterpret_cast<T*>(memory.location);`
`71`		`- for (ice::u32 idx = 0; idx < count; ++idx)`
	`71`	`+ for (ice::u64 idx = 0; idx < count; ++idx)`
`72`	`72`	`{`
`73`	`73`	`new (target_mem + idx) T{ objects[idx] };`
`74`	`74`	`}`
`@@ -84,9 +84,9 @@ namespace ice`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`template<typename T>`
`87`		`- void mem_destruct_n_at(T* location, ice::u32 count) noexcept`
	`87`	`+ void mem_destruct_n_at(T* location, ice::u64 count) noexcept`
`88`	`88`	`{`
`89`		`- for (ice::u32 idx = 0; idx < count; ++idx)`
	`89`	`+ for (ice::u64 idx = 0; idx < count; ++idx)`
`90`	`90`	`{`
`91`	`91`	`ice::mem_destruct_at(location + idx);`
`92`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace ice`
`11`	`11`	`template<typename T, typename U = T>`
`12`	`12`	`constexpr auto accumulate(ice::Span<T const> range, U val) noexcept`
`13`	`13`	`{`
`14`		`- return ::std::accumulate(ice::begin(range), ice::end(range), val);`
	`14`	`+ return ::std::accumulate(range.begin(), range.end(), val);`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`} // namespace ice`