Class.h

#pragma once
 
#include "krpch.h"
 
#include "Object.h"
 
namespace Karma
{
    /*-----------------------------------------------------------------------------
        UField.
    -----------------------------------------------------------------------------*/
 
    //
    // Base class of reflection data objects.
    //
    class KARMA_API UField : public UObject
    {
        DECLARE_KARMA_CLASS(UField, UObject)
 
        
        UField* m_Next;
 
        UClass* GetOwnerClass() const;
 
        //UStruct* GetOwnerStruct() const;
 
        const std::string& GetAuthoredName() const;
    };
 
    /*-----------------------------------------------------------------------------
        UStruct.
    -----------------------------------------------------------------------------*/
 
    class KARMA_API UStruct : public UField
    {
        DECLARE_KARMA_CLASS(UStruct, UField)
 
    public:
 
        bool IsChildOf(const UStruct* SomeBase) const;
 
        UStruct* GetSuperStruct() const
        {
            return m_SuperStruct;
        }
 
        FORCEINLINE size_t GetPropertiesSize() const
        {
            return m_PropertiesSize;
        }
 
        virtual void SetSuperStruct(UStruct* NewSuperStruct);
 
    private:
        UStruct* m_SuperStruct;
 
    public:
        size_t m_PropertiesSize;
 
        // Public?
        size_t m_MinAlignment;
    };
 
    class KARMA_API UClass : public UStruct
    {
        DECLARE_KARMA_CLASS(UClass, UStruct)
 
    public:
        UClass();
        UClass(const std::string& name);
 
        UClass(const std::string& name, size_t size, size_t alignment, ClassConstructorType inClassConstructor);
 
        //UClass* m_ClassWithin;
 
        // Only for hot reload purposes
        // typedef UObject* (*ClassVTableHelperCtorCallerType)  (FVTableHelper& Helper);
 
        ClassConstructorType m_ClassConstructor;
 
        EClassFlags m_ClassFlags;
 
    public:
        // UObject interface.
        virtual const std::string& GetDesc() override;
 
        FORCEINLINE bool HasAnyClassFlags(EClassFlags FlagsToCheck) const
        {
            return EnumHasAnyFlags(m_ClassFlags, FlagsToCheck) != 0;
        }
 
    public:
        virtual void SetupObjectInitializer(FObjectInitializer& ObjectInitializer) const {}
 
        UObject* GetDefaultObject(bool bCreateIfNeeded = true) const
        {
            if (/*m_ClassDefaultObject == nullptr &&*/ bCreateIfNeeded)
            {
                // some UE macro
                const_cast<UClass*>(this)->CreateDefaultObject();
            }
 
            return nullptr;//m_ClassDefaultObject;
        }
 
        template<class T>
        T* GetDefaultObject() const
        {
            UObject* Ret = GetDefaultObject();
            KR_CORE_ASSERT(Ret->IsA(T::StaticClass()), "Class {0} is not subclass of UObject");
            return (T*)Ret;
        }
 
        UClass* GetSuperClass() const
        {
            return (UClass*)GetSuperStruct();
        }
 
        FORCEINLINE size_t GetMinAlignment() const
        {
            return m_MinAlignment;
        }
 
        // UStruct interface.
        virtual void SetSuperStruct(UStruct* NewSuperStruct) override;
 
        virtual void InitPropertiesFromCustomList(uint8_t* DataPtr, const uint8_t* DefaultDataPtr) {}
 
    protected:
        virtual UObject* CreateDefaultObject();
 
    public:
        //UObject* m_ClassDefaultObject;
 
    private:
        //bool m_bLayoutChanging;
    };
}