Class.h

Go to the documentation of this file.

 
#pragma once
 
#include "Object.h"
 
namespace Karma
{
    /*-----------------------------------------------------------------------------
        UField.
    -----------------------------------------------------------------------------*/

    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;

        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);
 
        // The required type for the outer of instances of this class
        //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", T::GetName());
            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;
    };
}