Class.h

/******************************************************************
 * LClass
 *
 *
 *******************************************************************/
#pragma once
 
#include "LkEngine/Core/CoreMacros.h"
#include "LkEngine/Core/CoreTypes.h"
#include "LkEngine/Core/Template/TypeTrait.h"
#include "LkEngine/Core/LObject/ObjectBase.h"
 
 
namespace LkEngine {
 
    class LClass
    {
        using FObjectCastFunction = std::function<void*(LObjectBase*)>;
 
    public:
        explicit LClass(std::string_view InName, const std::type_index& InTypeID, FObjectCastFunction InCastFunction)
            : Name(InName)
            , TypeID(InTypeID)
            , CastFunction(std::move(InCastFunction))
        {
        }
 
        LClass() = default;
        virtual ~LClass() = default;
 
        FORCEINLINE const std::string& GetName() const 
        { 
            return Name; 
        }
 
        [[nodiscard]] FORCEINLINE const std::type_index& GetTypeID() const 
        { 
            return TypeID; 
        }
 
        static const LClass* Get(const std::type_index& ClassType)
        {
            if (auto Iter = ClassMetadataMap.find(ClassType); Iter != ClassMetadataMap.end())
            {
                return Iter->second.get();
            }
 
            return nullptr;
        }
 
        template<typename T>
        static LClass* Register(std::string_view ClassName)
        {
            static_assert(sizeof(T) > 0, "Register failed, incomplete type T");
            if (ClassMetadataMap.contains(typeid(T)))
            {
                return ClassMetadataMap[typeid(T)].get();
            }
 
            ClassMetadataMap[typeid(T)] = std::make_unique<LClass>(ClassName, typeid(T), [](LObjectBase* ClassObject) -> void* 
            { 
                return static_cast<T*>(ClassObject); 
            });
 
            LClass* Class = ClassMetadataMap[typeid(T)].get();
            Class->bRegistered = true;
 
            return Class;
        }
    
        bool operator==(const LClass& Other) const
        {
            return (TypeID == Other.TypeID);
        }
 
        FORCEINLINE bool IsRegistered() const 
        { 
            return bRegistered; 
        }
 
        bool IsChildOf(const LClass* OtherClass) const;
 
        template<typename T>
        bool IsChildOf() const
        {
            static_assert(sizeof(T) > 0, "IsChildOf failed, incomplete type T");
            return IsChildOf(T::StaticClass());
        }
 
    private:
        std::string Name{};
        std::type_index TypeID;
        FObjectCastFunction CastFunction;
 
        bool bRegistered = false;
 
        inline static std::unordered_map<std::type_index, std::unique_ptr<LClass>> ClassMetadataMap{};
    };
 
}