Object.h

#pragma once
#include <UnCompute/Memory/ReferenceCounter.h>
 
namespace UN
{
    class IObject
    {
    public:
        virtual ~IObject() = default;
 
        virtual UInt32 AddRef() = 0;
 
        virtual UInt32 Release() = 0;
 
        virtual void AttachRefCounter(ReferenceCounter* counter) = 0;
 
        virtual ReferenceCounter* GetRefCounter() = 0;
    };
 
    template<class TInterface, std::enable_if_t<std::is_base_of_v<IObject, TInterface>, bool> = true>
    class Object : public TInterface
    {
        ReferenceCounter* m_RefCounter = nullptr;
 
    protected:
        template<class F>
        inline UInt32 Release(F&& destroyCallback)
        {
            return m_RefCounter->ReleaseStrongRef([this, &destroyCallback] {
                destroyCallback();
                this->~Object();
            });
        }
 
    public:
        Object() = default;
 
        virtual ~Object() = default;
 
        Object(const Object&) = delete;
        Object(Object&&)      = delete;
 
        inline UInt32 AddRef() override
        {
            return m_RefCounter->AddStrongRef();
        }
 
        inline UInt32 Release() override
        {
            return Release([] {});
        }
 
        inline void AttachRefCounter(ReferenceCounter* pRefCounter) override
        {
            m_RefCounter = pRefCounter;
        }
 
        inline ReferenceCounter* GetRefCounter() override
        {
            return m_RefCounter;
        }
    };
} // namespace UN