Ptr.h

#pragma once
#include <UnCompute/Memory/Object.h>
 
namespace UN
{
    namespace Internal
    {
        template<class T>
        class PtrRef final
        {
            T* m_Ptr;
 
        public:
            using ObjectType = typename T::ObjectType;
 
            inline explicit PtrRef(T* ptr)
                : m_Ptr(ptr)
            {
            }
 
            inline operator ObjectType**() // NOLINT
            {
                return m_Ptr->ReleaseAndGetAddressOf();
            }
 
            inline ObjectType* operator*()
            {
                return m_Ptr->Get();
            }
        };
    } // namespace Internal
 
    template<class T>
    class Ptr final
    {
        T* m_pObject;
 
        template<class T1, class = void>
        struct IsComplete : std::false_type
        {
        };
 
        template<class T1>
        struct IsComplete<T1, decltype(void(sizeof(T1)))> : std::true_type
        {
        };
 
        template<class TBase, class TDerived, bool>
        struct IsBaseOf : std::true_type
        {
        };
 
        // NOTE: Check for completeness of the type is here to allow pointers that hold forward-declared classes
        template<class TBase, class TDerived>
        struct IsBaseOf<TBase, TDerived, true> : std::is_base_of<TBase, TDerived>
        {
        };
 
        static_assert(IsBaseOf<IObject, T, IsComplete<T>::value>::value,
                      "The template parameter in Ptr<T> must be a class or an interface derived from IObject");
 
        template<class T1>
        friend class Ptr;
 
        inline void InternalAddRef() const
        {
            if (m_pObject)
            {
                m_pObject->AddRef();
            }
        }
 
        inline UInt32 InternalRelease()
        {
            UInt32 result = 0;
            if (m_pObject)
            {
                result    = m_pObject->Release();
                m_pObject = nullptr;
            }
 
            return result;
        }
 
    public:
        using ObjectType = T;
 
        inline Ptr() noexcept
            : m_pObject(nullptr)
        {
        }
 
        inline Ptr(T* pObject) noexcept // NOLINT
            : m_pObject(pObject)
        {
            InternalAddRef();
        }
 
        inline Ptr(const Ptr& other) noexcept
            : m_pObject(other.m_pObject)
        {
            InternalAddRef();
        }
 
        template<class T1>
        inline Ptr(const Ptr<T1>& other) noexcept // NOLINT
            : m_pObject(other.Get())
        {
            InternalAddRef();
        }
 
        inline Ptr(Ptr&& other) noexcept
            : m_pObject(other.m_pObject)
        {
            other.m_pObject = nullptr;
        }
 
        inline void Swap(Ptr& other)
        {
            auto* t         = other.m_pObject;
            other.m_pObject = m_pObject;
            m_pObject       = t;
        }
 
        inline Ptr& operator=(const Ptr& other)
        {
            Ptr(other).Swap(*this);
            return *this;
        }
 
        inline Ptr& operator=(Ptr&& other) noexcept
        {
            Ptr(std::move(other)).Swap(*this);
            return *this;
        }
 
        inline void Reset()
        {
            Ptr{}.Swap(*this);
        }
 
        inline ~Ptr()
        {
            InternalRelease();
        }
 
        inline T* const* GetAddressOf() const
        {
            return &m_pObject;
        }
 
        inline T** GetAddressOf()
        {
            return &m_pObject;
        }
 
        inline T** ReleaseAndGetAddressOf()
        {
            InternalRelease();
            return &m_pObject;
        }
 
        inline void Attach(T* pObject)
        {
            InternalRelease();
            m_pObject = pObject;
        }
 
        inline T* Detach()
        {
            T* ptr    = m_pObject;
            m_pObject = nullptr;
            return ptr;
        }
 
        inline T* Get() const
        {
            return m_pObject;
        }
 
        template<class TDest>
        inline std::enable_if_t<std::is_base_of_v<TDest, T>, TDest*> As() const
        {
            return static_cast<TDest*>(Get());
        }
 
        template<class TDest>
        inline std::enable_if_t<std::is_base_of_v<T, TDest> && !std::is_same_v<T, TDest>, TDest*> As() const
        {
            return un_verify_cast<TDest*>(Get());
        }
 
        inline Internal::PtrRef<Ptr<T>> operator&() // NOLINT
        {
            return Internal::PtrRef<Ptr<T>>(this);
        }
 
        inline T& operator*()
        {
            return *Get();
        }
 
        inline T* operator->()
        {
            return Get();
        }
 
        inline const T& operator*() const
        {
            return *Get();
        }
 
        inline const T* operator->() const
        {
            return Get();
        }
 
        inline explicit operator bool() const
        {
            return m_pObject;
        }
    };
 
    template<class T>
    inline bool operator==(const Ptr<T>& lhs, std::nullptr_t)
    {
        return lhs.Get() == nullptr;
    }
 
    template<class T>
    inline bool operator!=(const Ptr<T>& lhs, std::nullptr_t)
    {
        return !(lhs == nullptr);
    }
 
    template<class T>
    inline bool operator==(std::nullptr_t, const Ptr<T>& rhs)
    {
        return rhs.Get() == nullptr;
    }
 
    template<class T>
    inline bool operator!=(std::nullptr_t, const Ptr<T>& rhs)
    {
        return !(nullptr == rhs);
    }
 
    template<class T1, class T2>
    inline bool operator==(const Ptr<T1>& lhs, T2* rhs)
    {
        return static_cast<IObject*>(lhs.Get()) == static_cast<IObject*>(rhs);
    }
 
    template<class T1, class T2>
    inline bool operator!=(const Ptr<T1>& lhs, T2* rhs)
    {
        return !(lhs == rhs);
    }
 
    template<class T1, class T2>
    inline bool operator==(T1* lhs, const Ptr<T2>& rhs)
    {
        return rhs == lhs;
    }
 
    template<class T1, class T2>
    inline bool operator!=(T1* lhs, const Ptr<T2>& rhs)
    {
        return !(lhs == rhs);
    }
 
    template<class T1, class T2>
    inline bool operator==(const Ptr<T1>& lhs, const Ptr<T2>& rhs)
    {
        return static_cast<IObject*>(lhs.Get()) == static_cast<IObject*>(rhs.Get());
    }
 
    template<class T1, class T2>
    inline bool operator!=(const Ptr<T1>& lhs, const Ptr<T2>& rhs)
    {
        return !(lhs == rhs);
    }
 
    template<class TDest, class TSrc>
    inline std::enable_if_t<std::is_base_of_v<TSrc, TDest>, Ptr<TDest>> un_verify_cast(const Ptr<TSrc>& pSourceObject)
    {
        return Ptr<TDest>(un_verify_cast<TDest*>(pSourceObject.Get()));
    }
} // namespace UN