Refactor a bunch of memory utilities

asl/allocator.cpp

@@ -24,7 +24,7 @@ void* asl::GlobalHeap::alloc(const layout& layout)
     return ptr;
 }
 
-void* asl::GlobalHeap::realloc(void* old_ptr, const layout& old_layout, const layout& new_layout)
+void* asl::GlobalHeap::realloc(void* old_ptr, [[maybe_unused]] const layout& old_layout, const layout& new_layout)
 {
 #if ASL_OS_WINDOWS
     return ::_aligned_realloc(old_ptr,

asl/box.hpp

@@ -58,10 +58,7 @@ public:
     {
         if (m_ptr != nullptr)
         {
-            if constexpr (!trivially_destructible<T>)
-            {
-                m_ptr->~T();
-            }
+            destruct(m_ptr);
             m_alloc.dealloc(m_ptr, layout::of<T>());
             m_ptr = nullptr;
         }
@@ -92,7 +89,7 @@ constexpr box<T, Allocator> make_box_in(Allocator allocator, Args&&... args)
     requires constructible_from<T, Args&&...>
 {
     void* raw_ptr = allocator.alloc(layout::of<T>());
-    T* ptr = new (raw_ptr) T(ASL_FWD(args)...);
+    auto* ptr = construct_at<T>(raw_ptr, ASL_FWD(args)...);
     return box(ptr, ASL_MOVE(allocator));
 }
 
@@ -102,7 +99,7 @@ constexpr box<T, Allocator> make_box(Args&&... args)
 {
     Allocator allocator{};
     void* raw_ptr = allocator.alloc(layout::of<T>());
-    T* ptr = new (raw_ptr) T{ ASL_FWD(args)... };
+    auto* ptr = construct_at<T>(raw_ptr, ASL_FWD(args)...);
     return box<T>(ptr, ASL_MOVE(allocator));
 }
 

asl/buffer.hpp

@@ -132,30 +132,7 @@ public:
 
         T* new_data = reinterpret_cast<T*>(m_allocator.alloc(new_layout));
 
-        // @Todo Move this logic somewhere else. Make move/destruct/etc. abstractions.
-
-        if constexpr (trivially_copyable<T>)
-        {
-            auto init_layout = layout::array<T>(current_size);
-            memcpy(new_data, old_data, init_layout.size);
-        }
-        else
-        {
-            static_assert(move_constructible<T>);
-            for (isize_t i = 0; i < current_size; ++i)
-            {
-                // NOLINTNEXTLINE(*-pointer-arithmetic)
-                new(new_data + i) T(ASL_MOVE(old_data[i]));
-            }
-        }
-
-        if constexpr (!trivially_destructible<T>)
-        {
-            for (isize_t i = 0; i < current_size; ++i)
-            {
-                (old_data + i)->~T();
-            }
-        }
+        relocate_uninit_n(new_data, old_data, current_size);
 
         if (currently_on_heap)
         {

asl/maybe_uninit.hpp

@@ -47,16 +47,13 @@ public:
     template<typename... Args>
     constexpr void init_unsafe(Args&&... args) &
     {
-        new(uninit_ptr()) T(ASL_FWD(args)...);
+        construct_at<T>(uninit_ptr(), ASL_FWD(args)...);
     }
 
     // @Safety Must be called only when in initialized state.
     constexpr void uninit_unsafe() &
     {
-        if constexpr (!trivially_destructible<T>)
-        {
-            init_ptr_unsafe()->~T();
-        }
+        destruct(init_ptr_unsafe());
     }
 };
 

asl/memory.hpp

@@ -1,6 +1,9 @@
 #pragma once
 
 #include "asl/integers.hpp"
+#include "asl/meta.hpp"
+#include "asl/layout.hpp"
+#include "asl/utility.hpp"
 
 constexpr void* operator new(size_t, void* ptr)
 {
@@ -25,5 +28,53 @@ constexpr isize_t strlen(const char* s)
     return static_cast<isize_t>(__builtin_strlen(s));
 }
 
+template<typename T, typename... Args>
+constexpr T* construct_at(void* ptr, Args&&... args)
+    requires constructible_from<T, Args&&...>
+{
+    return new (ptr) T{ ASL_FWD(args)... };
+}
+
+template<typename T>
+constexpr void destruct(T* data)
+{
+    if constexpr (!trivially_destructible<T>)
+    {
+        data->~T();
+    }
+}
+
+template<typename T>
+constexpr void destruct_n(T* data, isize_t n)
+{
+    if constexpr (!trivially_destructible<T>)
+    {
+        for (isize_t i = 0; i < n; ++i)
+        {
+            destruct(data + i);
+        }
+    }
+}
+
+template<typename T>
+constexpr void relocate_uninit_n(T* to, T* from, isize_t n)
+{
+    if constexpr (trivially_copyable<T>)
+    {
+        memcpy(to, from, size_of<T> * n);
+    }
+    else
+    {
+        static_assert(move_constructible<T>);
+        for (isize_t i = 0; i < n; ++i)
+        {
+            // NOLINTNEXTLINE(*-pointer-arithmetic)
+            construct_at<T>(to + i, ASL_MOVE(from[i]));
+        }
+    }
+    
+    destruct_n(from, n);
+}
+
 } // namespace asl
 

asl/option.hpp

@@ -88,7 +88,7 @@ class option
 
         if constexpr (kHasInlinePayload)
         {
-            new (&m_payload) T(ASL_FWD(args)...);
+            construct_at<T>(&m_payload, ASL_FWD(args)...);
         }
         else
         {
@@ -389,11 +389,8 @@ public:
             }
             else
             {
-                if constexpr (!trivially_destructible<T>)
-                {
-                    (&m_payload)->~T();
-                }
-                new (&m_payload) T(niche{});
+                destruct(&m_payload);
+                construct_at<T>(&m_payload, niche{});
             }
         }
         else