From d76e64c0626a5964bb5159fc8ae21182037cf4a1 Mon Sep 17 00:00:00 2001
From: Patrick Wuttke <p.wuttke@dsfishlabs.com>
Date: Sat, 30 Aug 2025 00:30:09 +0200
Subject: [PATCH] Fixed converting auf DynamicPointers, added wrapDynamic
 helper to simplify creating non-owning DynamicPointers.

---
 source/mijin/memory/dynamic_pointer.hpp | 26 ++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/source/mijin/memory/dynamic_pointer.hpp b/source/mijin/memory/dynamic_pointer.hpp
index 92ed97e..4e48b95 100644
--- a/source/mijin/memory/dynamic_pointer.hpp
+++ b/source/mijin/memory/dynamic_pointer.hpp
@@ -35,10 +35,11 @@ public:
     {
         MIJIN_ASSERT((std::bit_cast<std::uintptr_t>(ptr) & 1) == 0, "Invalid address, DynamicPointer requires addresses to be divisible by two.");
     }
-    template<typename TOther, typename TOtherDeleter> requires (std::is_constructible_v<TDeleter, TOtherDeleter&&>)
+    template<typename TOther, typename TOtherDeleter> requires (std::is_assignable_v<T*&, TOther*> && std::is_constructible_v<TDeleter, TOtherDeleter&&>)
     constexpr DynamicPointer(DynamicPointer<TOther, TOtherDeleter>&& other) MIJIN_NOEXCEPT_IF((std::is_nothrow_convertible_v<TOtherDeleter, TDeleter>))
-        : mData(std::exchange(other.mData, 0)), mDeleter(std::move(other.mDeleter)) {
-        MIJIN_ASSERT(other.mData == 0, "");
+        : DynamicPointer(other.get(), other.isOwning() ? Owning::YES : Owning::NO, TDeleter(std::move(other.mDeleter)))
+    {
+        other.mData = 0;
     }
     constexpr ~DynamicPointer() noexcept
     {
@@ -64,6 +65,15 @@ public:
         return *this;
     }
 
+    // template<typename TOther, typename TOtherDeleter> requires (std::is_base_of_v<TOther, T>)
+    // constexpr operator DynamicPointer<TOther, TOtherDeleter>() && // MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible_v<TDeleter>>)
+    // {
+    //     const Owning owning = isOwning() ? Owning::YES : Owning::NO;
+    //     T* const ptr = release();
+    // 
+    //     return DynamicPointer<TOther, TOtherDeleter>(static_cast<TOther*>(ptr), owning, TOtherDeleter(std::move(mDeleter)));
+    // }
+
     template<typename TOther, typename TOtherDeleter> requires(std::equality_comparable_with<T, TOther>)
     auto operator<=>(const DynamicPointer<TOther, TOtherDeleter>& other) MIJIN_NOEXCEPT
     {
@@ -155,9 +165,9 @@ bool operator!=(std::nullptr_t, const DynamicPointer<T, TDeleter>& pointer) MIJI
 }
 
 template<typename T, typename... TArgs>
-DynamicPointer<T, std::default_delete<T>> makeDynamic(TArgs&&... args) MIJIN_NOEXCEPT_IF((std::is_nothrow_constructible_v<T, TArgs...>))
+DynamicPointer<T> makeDynamic(TArgs&&... args) MIJIN_NOEXCEPT_IF((std::is_nothrow_constructible_v<T, TArgs...>))
 {
-    return DynamicPointer<T, std::default_delete<T>>(new T(std::forward<TArgs>(args)...), Owning::YES);
+    return DynamicPointer<T>(new T(std::forward<TArgs>(args)...), Owning::YES);
 }
 
 template<typename T, allocator_type_for<T> TAllocator, typename... TArgs>
@@ -171,6 +181,12 @@ DynamicPointer<T, AllocatorDeleter<TAllocator>> makeDynamicWithAllocator(TAlloca
     }
     return DynamicPointer<T, AllocatorDeleter<TAllocator>>(obj, Owning::YES, AllocatorDeleter<TAllocator>(std::move(allocator)));
 }
+
+template<typename T>
+DynamicPointer<T> wrapDynamic(T* raw)
+{
+    return DynamicPointer<T>(raw, Owning::NO);
+}
 } // namespace mijin
 
 #endif // !defined(MIJIN_MEMORY_DYNAMIC_POINTER_HPP_INCLUDED)