UObjectBase.h

Go to the documentation of this file.

 
/*=============================================================================
    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;

        bool IsUnreachable() const;

        FORCEINLINE void SetInternalIndex(uint32_t StoreIndex) { m_InternalIndex = StoreIndex; }

        FORCEINLINE uint32_t GetInternalIndex() 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
        {
            // Atm we don't have the cyclic dependency therefore we have forward declared
            // UClass. Maybe we will have some dependency in future, then
            // when we have a cyclic dependency between UObjectBase and UClass,
            // 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;
 
            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
            KR_CORE_ASSERT(ThisClass, "Couldn't find UClass of {0}. Comparing with null is useless", this->GetName());
 
            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 FlagsToClear)
        {
            KR_CORE_ASSERT(!(FlagsToClear & (RF_MarkAsNative | RF_MarkAsRootSet | RF_PendingKill | RF_Garbage)) || FlagsToClear == RF_AllFlags, "These flags can't be used outside of constructors / internal code");
            KR_CORE_ASSERT(!(FlagsToClear & (EObjectFlags)(RF_PendingKill | RF_Garbage)) || (GetFlags() & (FlagsToClear & (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() & ~FlagsToClear));
        }

        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);
    };
}