UObjectBase.h

 
/*=============================================================================
    UObjectBase.h: Base class for UObject, defines low level functionality
=============================================================================*/
 
#pragma once
 
#include "Core/UObjectGlobals.h"
 
namespace Karma
{
    class UObject;
    class UClass;
 
    class UPackage;
 
    #define RF_AllFlags             (EObjectFlags)0xffffffff    
 
    class KARMA_API UObjectBase
    {
    protected:
        UObjectBase();
 
        FORCEINLINE void SetFlagsTo(EObjectFlags NewFlags)
        {
            KR_CORE_ASSERT((NewFlags & ~RF_AllFlags) == 0, "%s flagged as 0x%x but is trying to set flags to RF_AllFlags");
            m_ObjectFlags = NewFlags;
        }
 
    public:
        UObjectBase(UClass* inClass, EObjectFlags inFlags, EInternalObjectFlags inInternalFlags, UObject* inOuter, const std::string& inName);
 
        UPackage* GetPackage() const;
 
        UPackage* GetExternalPackage() const;
 
        // Caution: use with vigilance
        bool IsUnreachable() const;
 
        FORCEINLINE void SetInternalIndex(uint32_t StoreIndex) { m_InternalIndex = StoreIndex; }
 
        FORCEINLINE uint32_t GetInterIndex() const { return m_InternalIndex; }
 
    private:
 
        EObjectFlags                    m_ObjectFlags;
 
        uint32_t                            m_InternalIndex;
 
        UObject* m_OuterPrivate;
 
        UClass* m_ClassPrivate;
 
        std::string                         m_NamePrivate;
 
        static bool m_bPendingKillDisabled;
 
    private:
        void AddObject(const std::string& name, EInternalObjectFlags inSetInternalFlags);
 
    public:
        void MarkAsGarbage();
 
        void ClearGarbage();
 
        FORCEINLINE const std::string& GetName() const
        {
            return m_NamePrivate;
        }
 
        FORCEINLINE void SetObjectName(const std::string& aName)
        {
            m_NamePrivate = aName;
        }
 
        FORCEINLINE UObject* GetOuter() const
        {
            return m_OuterPrivate;
        }
 
        UObject* GetTypedOuter(UClass* Target) const;
 
        template<typename T>
        T* GetTypedOuter() const
        {
            return (T*)GetTypedOuter(T::StaticClass());
        }
 
        bool IsValidLowLevel() const;
 
        FORCEINLINE static EInternalObjectFlags FixGarbageOrPendingKillInternalObjectFlags(const EInternalObjectFlags InFlags)
        {
            //PRAGMA_DISABLE_DEPRECATION_WARNINGS
            if (!(int32_t(InFlags) & (int32_t(EInternalObjectFlags::Garbage) | int32_t(EInternalObjectFlags::PendingKill))))
            {
                // Pass through
                return InFlags;
            }
            else
            {
                return m_bPendingKillDisabled ?
                    EInternalObjectFlags(((int32_t(InFlags) & ~int32_t(EInternalObjectFlags::PendingKill)) | int32_t(EInternalObjectFlags::Garbage))) : // Replace PK with Garbage
                    EInternalObjectFlags(((int32_t(InFlags) & ~int32_t(EInternalObjectFlags::Garbage)) | int32_t(EInternalObjectFlags::PendingKill))); // Replace Garbage with PK
            }
            //PRAGMA_ENABLE_DEPRECATION_WARNINGS
        }
 
 
    public:
        template <typename OtherClassType>
        FORCEINLINE bool IsA(OtherClassType SomeBase) const
        {
            // We have a cyclic dependency between UObjectBase and UClass,
            // so we use a template to allow inlining of something we haven't yet seen, because it delays compilation until the function is called.
 
            // 'static_assert' that this thing is actually a UClass pointer or convertible to it.
            const UClass* SomeBaseClass = SomeBase;
            (void)SomeBaseClass;
            KR_CORE_ASSERT(SomeBaseClass, "IsA(NULL) cannot yield meaningful results");
 
            const UClass* ThisClass = GetClass();
 
            // Stop the compiler doing some unnecessary branching for nullptr checks
            // Would be interesting to write the analog of this
            //UE_ASSUME(SomeBaseClass);
            //UE_ASSUME(ThisClass);
 
            KR_CORE_ASSERT(ThisClass, "Comparing with null is useless");
 
            return IsChildOfWorkaround(ThisClass, SomeBaseClass);
        }
 
        FORCEINLINE UClass* GetClass() const
        {
            return m_ClassPrivate;
        }
 
        /*-------------------
            Flags
        -------------------*/
 
        FORCEINLINE EObjectFlags GetFlags() const
        {
            KR_CORE_ASSERT((m_ObjectFlags & ~RF_AllFlags) == 0, "{0} flagged as RF_ALLFlags", GetName());
            return m_ObjectFlags;
        }
 
        FORCEINLINE void SetFlags(EObjectFlags NewFlags)
        {
            KR_CORE_ASSERT(!(NewFlags & (RF_MarkAsNative | RF_MarkAsRootSet | RF_PendingKill | RF_Garbage)), "These flags can't be used outside of constructors / internal code");
            KR_CORE_ASSERT(!(NewFlags & (EObjectFlags)(RF_PendingKill | RF_Garbage)) || (GetFlags() & (NewFlags & (EObjectFlags)(RF_PendingKill | RF_Garbage))) == (NewFlags & (EObjectFlags)(RF_PendingKill | RF_Garbage)), "RF_PendingKill and RF_garbage can not be set through SetFlags function. Use MarkAsGarbage() instead");
 
            SetFlagsTo(EObjectFlags (GetFlags() | NewFlags));
        }
 
        FORCEINLINE void ClearFlags(EObjectFlags NewFlags)
        {
            KR_CORE_ASSERT(!(NewFlags & (RF_MarkAsNative | RF_MarkAsRootSet | RF_PendingKill | RF_Garbage)) || NewFlags == RF_AllFlags, "These flags can't be used outside of constructors / internal code");
            KR_CORE_ASSERT(!(NewFlags & (EObjectFlags)(RF_PendingKill | RF_Garbage)) || (GetFlags() & (NewFlags & (EObjectFlags)(RF_PendingKill | RF_Garbage))) == RF_NoFlags, "RF_PendingKill and RF_garbage can not be cleared through ClearFlags function. Use ClearGarbage() instead");
 
            SetFlagsTo(EObjectFlags (GetFlags() & ~NewFlags));
        }
 
        FORCEINLINE bool HasAnyFlags(EObjectFlags FlagsToCheck) const
        {
            KR_CORE_ASSERT(!(FlagsToCheck & (RF_MarkAsNative | RF_MarkAsRootSet)) || FlagsToCheck == RF_AllFlags, "Illegal flags being used"); // These flags can't be used outside of constructors / internal code
            return (GetFlags() & FlagsToCheck) != 0;
        }
 
        FORCEINLINE bool HasAnyInternalFlags(EInternalObjectFlags FlagsToCheck) const
        {
            return GUObjectStore.IndexToObject(m_InternalIndex)->HasAnyFlags(FlagsToCheck);
        }
 
        FORCEINLINE void SetInternalFlags(EInternalObjectFlags FlagsToSet) const
        {
            FUObjectItem* ObjectItem = GUObjectStore.IndexToObject(m_InternalIndex);
            KR_CORE_ASSERT(!(int32_t(FlagsToSet) & (int32_t(EInternalObjectFlags::PendingKill) | int32_t(EInternalObjectFlags::Garbage))) || (int32_t(FlagsToSet) & (int32_t(EInternalObjectFlags::PendingKill) | int32_t(EInternalObjectFlags::Garbage))) == (int32_t(ObjectItem->GetFlags()) & (int32_t(EInternalObjectFlags::PendingKill) | int32_t(EInternalObjectFlags::Garbage))), "");
 
            ObjectItem->SetFlags(FlagsToSet);
        }
 
        FORCEINLINE void AddToRoot()
        {
            // Need to understand the logic of GC first
            //GUObjectStore.IndexToObject(InternalIndex)->SetRootSet();
        }
 
        /*-------------------
            Class
        -------------------*/
 
    private:
 
        static bool IsChildOfWorkaround(const UClass* ObjClass, const UClass* TestClass);
 
        //static FORCEINLINE bool IsChildOfWorkaround(const ClassType* ObjClass, const ClassType* TestCls);
        //{
        //  return ObjClass->IsChildOf(TestCls);
        //}
    };
}