mem_unique_ptr.hxx

Go to the documentation of this file.

 
#pragma once
#include <ice/mem_allocator.hxx>
 
namespace ice
{
 
    template<typename T>
    struct UniquePtr;
 
    template<typename T, typename... Args>
    inline auto make_unique(ice::Allocator& alloc, Args&&... args) noexcept -> ice::UniquePtr<T>;
 
    template<typename T>
    using UniquePtrCustomDeleter = void(T*) noexcept;
 
    template<typename T>
    inline auto make_unique(ice::UniquePtrCustomDeleter<T>* fn_deleter, T* instanced_object) noexcept -> ice::UniquePtr<T>;
 
 
    template<typename T>
    struct UniquePtr
    {
        struct UserDeleterInfo;
 
        inline UniquePtr() noexcept;
        inline ~UniquePtr() noexcept;
 
        inline explicit UniquePtr(ice::Allocator* alloc, T* ptr) noexcept;
        inline explicit UniquePtr(ice::UniquePtrCustomDeleter<T>* deleter_fn, T* ptr) noexcept;
 
        inline UniquePtr(UniquePtr&& other) noexcept;
        template<typename U> requires std::is_base_of_v<T, U>
        inline UniquePtr(UniquePtr<U>&& other) noexcept;
 
        inline auto operator=(UniquePtr&& other) noexcept -> UniquePtr&;
        template<typename U> requires std::is_base_of_v<T, U>
        inline auto operator=(UniquePtr<U>&& other) noexcept -> UniquePtr&;
        inline auto operator=(std::nullptr_t) noexcept -> UniquePtr&;
 
        bool operator==(std::nullptr_t) const noexcept { return _ptr == nullptr; }
 
        auto operator->() const noexcept -> T* { return _ptr; }
        auto operator*() const noexcept -> T& { return *_ptr; }
 
        inline auto get() const noexcept -> T* { return _ptr; }
        inline void reset() noexcept;
 
        Allocator* _alloc;
        T* _ptr;
        void* _deleter;
    };
 
    template<typename T>
    struct UniquePtr<T>::UserDeleterInfo
    {
        //ice::Allocator* alloc;
        ice::UniquePtrCustomDeleter<T>* fn_deleter;
    };
 
    template<typename T>
    inline UniquePtr<T>::UniquePtr() noexcept
        : _alloc{ nullptr }
        , _ptr{ nullptr }
    { }
 
    template<typename T>
    inline UniquePtr<T>::~UniquePtr() noexcept
    {
        reset();
    }
 
    template<typename T>
    inline UniquePtr<T>::UniquePtr(ice::Allocator* alloc, T* ptr) noexcept
        : _alloc{ alloc }
        , _ptr{ ptr }
        , _deleter{ nullptr }
    { }
 
    template<typename T>
    inline UniquePtr<T>::UniquePtr(ice::UniquePtrCustomDeleter<T>* deleter_fn, T* ptr) noexcept
        : _alloc{ nullptr }
        , _ptr{ ptr }
        , _deleter{ reinterpret_cast<void*>(deleter_fn) }
    { }
 
    template<typename T>
    inline UniquePtr<T>::UniquePtr(UniquePtr&& other) noexcept
        : _alloc{ std::exchange(other._alloc, nullptr) }
        , _ptr{ std::exchange(other._ptr, nullptr) }
        , _deleter{ std::exchange(other._deleter, nullptr) }
    {
    }
 
    template<typename T>
    template<typename U> requires std::is_base_of_v<T, U>
    inline UniquePtr<T>::UniquePtr(UniquePtr<U>&& other) noexcept
        : _alloc{ std::exchange(other._alloc, nullptr) }
        , _ptr{ std::exchange(other._ptr, nullptr) }
        , _deleter{ std::exchange(other._deleter, nullptr) }
    {
    }
 
    template<typename T>
    inline auto UniquePtr<T>::operator=(UniquePtr&& other) noexcept -> UniquePtr&
    {
        if (this != &other)
        {
            reset();
 
            _alloc = std::exchange(other._alloc, nullptr);
            _ptr = std::exchange(other._ptr, nullptr);
            _deleter = std::exchange(other._deleter, nullptr);
        }
        return *this;
    }
 
    template<typename T>
    template<typename U> requires std::is_base_of_v<T, U>
    inline auto UniquePtr<T>::operator=(UniquePtr<U>&& other) noexcept -> UniquePtr&
    {
        reset();
 
        _alloc = std::exchange(other._alloc, nullptr);
        _ptr = std::exchange(other._ptr, nullptr);
        _deleter = std::exchange(other._deleter, nullptr);
        return *this;
    }
 
    template<typename T>
    inline auto UniquePtr<T>::operator=(std::nullptr_t) noexcept -> UniquePtr&
    {
        reset();
        return *this;
    }
 
    template<typename T>
    inline void UniquePtr<T>::reset() noexcept
    {
        if (_ptr == nullptr)
        {
            return;
        }
 
        // If we don't have a 'special' case
        if (_alloc != nullptr)
        {
            if constexpr (ice::is_type_complete<T>)
            {
                ICE_ASSERT_CORE(_deleter == nullptr); // TODO: Implement various deleters
                _alloc->destroy(_ptr);
            }
            else
            {
                //static_assert(ice::is_type_complete<T>);
                ICE_ASSERT_CORE(_deleter != nullptr); // MEMORY LEAK INBOUND! Cannot delete object of incomplete type!
            }
        }
        else
        {
            ICE_ASSERT_CORE(_deleter != nullptr); // TODO: Implement various deleters
            ice::UniquePtrCustomDeleter<T>* fn_deleter = std::bit_cast<ice::UniquePtrCustomDeleter<T>*>(_deleter);
            fn_deleter(_ptr);
        }
 
        _alloc = nullptr;
        _ptr = nullptr;
        _deleter = nullptr;
    }
 
    template<typename T, typename... Args>
    concept MakeUniqueConstructorAvailable = requires(Args&&... args) {
        { new T{ std::forward<Args>(args)... } } -> std::convertible_to<T*>;
    };
 
    template<typename T, typename... Args>
    inline auto make_unique(ice::Allocator& alloc, Args&&... args) noexcept -> ice::UniquePtr<T>
    {
        static_assert(std::is_abstract_v<T> == false, "Can't instantiate an abstract type!");
        static_assert(MakeUniqueConstructorAvailable<T, decltype(ice::forward<Args>(args))...>, "Can't call the constructor for the given type and arguments!");
        return ice::UniquePtr<T>{ &alloc, alloc.create<T>(ice::forward<Args>(args)...) };
    }
 
    template<typename T>
    inline auto make_unique(ice::UniquePtrCustomDeleter<T>* fn_deleter, T* instanced_object) noexcept -> ice::UniquePtr<T>
    {
        return ice::UniquePtr<T>{ fn_deleter, instanced_object };
    }
 
} // namespace ice