Object.h

Go to the documentation of this file.

 
#pragma once
 
#include <set>
#include <typeindex>
#include <typeinfo>
#include <type_traits>
 
#include "LkEngine/Core/CoreMacros.h"
#include "LkEngine/Core/LObject/Class.h"
#include "LkEngine/Core/LObject/ObjectBase.h"
#include "LkEngine/Core/MetadataRegistry.h"
 
namespace LkEngine {
 
    using FObjectHandle = LUUID;
 
    class LMetadataRegistry;
 
    template<typename T>
    class TObjectPtr;
 
    class LObject : public LObjectBase
    {
    public:
        LObject();
 
        LObject(const LObject& Other)
            : ObjectHandle(Other.ObjectHandle)
            , bObjectInitialized(Other.bObjectInitialized)
            , ObjectFlags(Other.ObjectFlags)
            , Ptr_ReferenceCount(Other.Ptr_ReferenceCount.load())
        {
        }
 
        virtual ~LObject() = default;
 
        virtual void Initialize();
 
        virtual void Destroy() {};
 
        FORCEINLINE virtual bool IsInitialized() const { return bObjectInitialized; }
 
        FORCEINLINE FObjectHandle GetObjectHandle() const { return ObjectHandle; }
 
        FORCEINLINE virtual bool IsObjectValid() const
        {
            if (HasAnyFlags(EObjectFlag::Garbage | EObjectFlag::BeginDestroy | EObjectFlag::FinishDestroy))
            {
                return false;
            }
 
            return true;
        }
 
        FORCEINLINE static const LClass* StaticClass()
        {
            static bool bClassRegistered = false;
            if (!bClassRegistered)
            {
                LClass* ObjectClass = LClass::Register<LObject>("LObject");
                bClassRegistered = true;
            }
 
            return LClass::Get(LType<LObject>::ID());
        }
 
        virtual const LClass* ObjectRegistration() = 0;
 
        FORCEINLINE static std::string StaticClassName() { return "LObject"; }
 
        FORCEINLINE virtual const LClass* GetClass() const
        {
            return LObjectBase::GetClass();
        }
 
        virtual std::string ClassName() const = 0;
 
        LObject& operator=(const LObject& Other)
        {
            if (this == &Other)
            {
                return *this;
            }
 
            ObjectHandle = Other.ObjectHandle;
            bObjectInitialized = Other.bObjectInitialized;
            ObjectFlags = Other.ObjectFlags;
            Ptr_ReferenceCount = Other.Ptr_ReferenceCount.load();
 
            return *this;
        }
 
        void MarkAsGarbage()
        {
            ObjectFlags |= EObjectFlag::Garbage;
        }
 
        template<typename T>
        T& As()
        {
            static_assert(sizeof(T) > 0, "As<T> failed, incomplete type");
            return static_cast<T&>(*this);
        }
 
        template<typename T>
        const T& As() const
        {
            static_assert(sizeof(T) > 0, "As<T> failed, incomplete type");
            return static_cast<const T&>(*this);
        }
 
        template<typename T>
        bool IsA() const
        {
            static_assert(sizeof(T) > 0, "IsA<T> failed, incomplete type");
            return (GetClass()->GetName() == T::StaticClassName()); 
        }
 
        FORCEINLINE virtual bool IsAsset() const { return false; }
 
        FORCEINLINE uint32_t GetReferenceCount() const { return Ptr_ReferenceCount.load(); }
 
        template <typename T>
        static void ValidateLObjectImplementation()
        {
            static_assert(HasLClassMacro<T>, "Class must include the LCLASS macro");
        }
 
    private:
        FORCEINLINE bool HasFlag(const EObjectFlag InFlag) const
        {
            return ((ObjectFlags & InFlag) == static_cast<std::underlying_type_t<EObjectFlag>>(InFlag));
        }
 
        FORCEINLINE bool HasAnyFlags(const EObjectFlag InFlags) const
        {
            return static_cast<bool>(ObjectFlags & InFlags);
        }
 
    private:
        FORCEINLINE void IncrementReferenceCount() const
        {
            Ptr_ReferenceCount++;
        }
 
        FORCEINLINE void DecrementReferenceCount() const
        {
            LK_CORE_ASSERT(Ptr_ReferenceCount > 0, "LObject::DecrementReferenceCount failed");
            Ptr_ReferenceCount--;
        }
 
    protected:
        FObjectHandle ObjectHandle = 0;
 
        bool bObjectInitialized = false;
        EObjectFlag ObjectFlags = EObjectFlag::None;
 
        mutable std::atomic<uint32_t> Ptr_ReferenceCount = 0;
 
        template<typename T>
        friend class TObjectPtr;
 
        friend struct FInternalLObjectValidator;
    };
 
    struct FInternalLObjectValidator
    {
        FORCEINLINE static bool CheckObjectValidBasedOnFlags(const LObject* Object)
        {
            return !(Object->HasAnyFlags(EObjectFlag::Garbage));
        }
    };
 
    FORCEINLINE bool IsValid(const LObject* Object)
    {
        return (Object && FInternalLObjectValidator::CheckObjectValidBasedOnFlags(Object));
    }
 
    FORCEINLINE bool IsValid(const LObject& Object)
    {
        return IsValid(&Object);
    }
 
    template<typename TObject>
    inline constexpr bool IsBaseOfObject = std::is_base_of<LObject, std::decay_t<TObject>>::value;
 
}
 
namespace std 
{
    template<>
    struct hash<LkEngine::LObject>
    {
        std::size_t operator()(const LkEngine::LObject& Object) const noexcept
        {
            return std::hash<uint64_t>()(Object.GetObjectHandle());
        }
    };
}