UObjectBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UObjectBase.h: Base class for UObject, defines low level functionality
=============================================================================*/
 
#pragma once
 
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "HAL/LowLevelMemTracker.h"
#include "HAL/PlatformAtomics.h"
#include "HAL/PlatformMath.h"
#include "Misc/AssertionMacros.h"
#include "Stats/Stats.h"
#include "UObject/NameTypes.h"
#include "UObject/RemoteObjectTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/ObjectPtr.h"
#include "AutoRTFM.h"
 
class UClass;
class UEnum;
class UObject;
class UPackage;
class UScriptStruct;
 
namespace UE::CoreUObject::Private
{
    struct FObjectHandleUtils;
}
 
namespace UE::CoreUObject
{
#if UE_WITH_CONSTINIT_UOBJECT
    // Finish constructing compiled-in objects with operations that can only be done at runtime
    // (i.e. creating FNames) but do not create any class default objects and minimize callbacks
    // to other systems (i.e. FCoreUObjectDelegates::CompiledInUObjectsRegisteredDelegate)
    // Expected to be called from Launch before any systems that want basic access to compiled-in
    // objects such as classes and structs for reflection (i.e. reading config via reflection).
    COREUOBJECT_API void ConstructCompiledInObjects();
#endif 
}
 
// If FName is 4 bytes than we can use padding after it to store internal object list index and use array instead of a hash map for lookup in UObjectHash.cpp
// This might change the each UClass' object list iteration order
#if !defined(UE_STORE_OBJECT_LIST_INTERNAL_INDEX)
#   define UE_STORE_OBJECT_LIST_INTERNAL_INDEX 0
#endif
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("STAT_UObjectsStatGroupTester"), STAT_UObjectsStatGroupTester, STATGROUP_UObjects, COREUOBJECT_API);
 
class UObjectBase
{
    friend class UObjectBaseUtility;
    friend struct Z_Construct_UClass_UObject_Statics;
    friend class FUObjectArray; // for access to InternalIndex without revealing it to anyone else
    friend class FUObjectAllocator; // for access to destructor without revealing it to anyone else
    friend struct FInternalUObjectBaseUtilityIsValidFlagsChecker; // for access to InternalIndex
    friend struct UE::CoreUObject::Private::FObjectHandleUtils; // for access to OuterPrivate
    friend COREUOBJECT_API void UObjectForceRegistration(UObjectBase* Object, bool bCheckForModuleRelease);
    friend COREUOBJECT_API void InitializePrivateStaticClass(
        class UClass* (*TClass_StaticClassFn)(),
        class UClass* TClass_Super_StaticClass,
        class UClass* TClass_PrivateStaticClass,
        class UClass* TClass_WithinClass_StaticClass,
        const TCHAR* PackageName,
        const TCHAR* Name
        );
    friend COREUOBJECT_API UObject* StaticAllocateObject( // for access to ObjectListInternalIndex
        const UClass*,
        UObject*,
        FName,
        EObjectFlags,
        EInternalObjectFlags,
        bool,
        bool*,
        UPackage*,
        int32,
        FRemoteObjectId,
        class FGCReconstructionGuard*);
 
protected:
    UObjectBase() :
        ClassPrivate(NoInit),
        NamePrivate(NoInit),  // screwy, but the name was already set and we don't want to set it again
        OuterPrivate(NoInit)
    {
    }
 
#if UE_WITH_CONSTINIT_UOBJECT
public:
    explicit consteval UObjectBase(UE::CodeGen::ConstInit::FObjectParams InParams)
        : ObjectFlags(InParams.Flags | RF_MarkAsNative | RF_MarkAsRootSet | RF_NeedInitialization)
        , InternalIndex(INDEX_NONE)
        , ClassPrivate(ConstEval, InParams.Class)
        , UninitializedNameUTF8(InParams.NameUTF8)
        , OuterPrivate(InParams.Outer)
    {
    }
protected:
#endif
 
    COREUOBJECT_API UObjectBase( EObjectFlags InFlags );
public:
 
    COREUOBJECT_API UObjectBase(UClass* InClass,
            EObjectFlags InFlags,
            EInternalObjectFlags InInternalFlags,
            UObject *InOuter,
            FName InName,
            int32 InInternalIndex = -1,
            int32 InSerialNumber = 0,
            FRemoteObjectId InRemoteId = FRemoteObjectId());
 
    COREUOBJECT_API virtual ~UObjectBase();
 
protected:
    COREUOBJECT_API void LowLevelRename(FName NewName,UObject *NewOuter = NULL);
 
#if !UE_WITH_CONSTINIT_UOBJECT
    virtual void RegisterDependencies() {}
 
    COREUOBJECT_API void Register(class UClass* (*StaticClassFn)(), const TCHAR* PackageName, const TCHAR* Name);
    UE_DEPRECATED(5.6, "Use the new method above and specify UClass::StaticClass as the first argument")
    COREUOBJECT_API void Register(const TCHAR* PackageName, const TCHAR* Name);
#endif // !UE_WITH_CONSTINIT_UOBJECT
 
    COREUOBJECT_API virtual void DeferredRegister(UClass* UClassStaticClass, const TCHAR* PackageName, const TCHAR* Name
#if UE_WITH_REMOTE_OBJECT_HANDLE
        , FRemoteObjectId InRemoteId
#endif
    );
 
private:
    COREUOBJECT_API void AddObject(FName Name, EInternalObjectFlags InSetInternalFlags, int32 InInternalIndex = -1, int32 InSerialNumber = 0, FRemoteObjectId InRemoteId = FRemoteObjectId());
 
    COREUOBJECT_API bool IsValidLowLevelForDestruction() const;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    FRemoteObjectId GetPendingRegistrantRemoteId() const;
#endif
 
public:
    COREUOBJECT_API bool IsValidLowLevel() const;
 
    COREUOBJECT_API bool IsValidLowLevelFast(bool bRecursive = true) const;
 
    FORCEINLINE uint32 GetUniqueID() const
    {
        return (uint32)InternalIndex;
    }
 
    FORCEINLINE UClass* GetClass() const
    {
        return ClassPrivate;
    }
    
    FORCEINLINE UObject* GetOuter() const
    {
#if UE_WITH_REMOTE_OBJECT_HANDLE
        return ObjectPtr_Private::Friend::NoAccessTrackingGetNoResolve(OuterPrivate.GetAccessTrackedObjectPtr());
#else
        return OuterPrivate;
#endif
    }
 
    FORCEINLINE FName GetFName() const
    {
#if UE_WITH_CONSTINIT_UOBJECT
        checkfSlow(!EnumHasAllFlags((EObjectFlags)GetFlagsInternal(), RF_NeedInitialization|RF_MarkAsNative), TEXT("UObjectBase::GetFName called on a native object which is not yet initialized."));
#endif // UE_WITH_CONSTINIT_UOBJECT
        return NamePrivate.Name;
    }
 
    COREUOBJECT_API virtual FName GetFNameForStatID() const;
 
    static COREUOBJECT_API FString RemoveClassPrefix(const TCHAR* ClassName);
 
    COREUOBJECT_API UPackage* GetExternalPackage() const;
    
    COREUOBJECT_API void SetExternalPackage(UPackage* InPackage);
 
    COREUOBJECT_API UPackage* GetExternalPackageInternal() const;
 
    COREUOBJECT_API void MarkAsReachable() const;
 
    COREUOBJECT_API void AddRef() const;
 
    COREUOBJECT_API void ReleaseRef() const;
 
protected:
    UE_DEPRECATED(5.3, "This function is not thread-safe. Use AtomicallySetFlags or AtomicallyClearFlags instead.")
    FORCEINLINE void SetFlagsTo( EObjectFlags NewFlags )
    {
        checkfSlow((NewFlags & ~RF_AllFlags) == 0, TEXT("%s flagged as 0x%x but is trying to set flags to RF_AllFlags"), *GetFName().ToString(), (int)ObjectFlags);
        ObjectFlags = NewFlags;
    }
 
public:
    FORCEINLINE EObjectFlags GetFlags() const
    {
        EObjectFlags Flags = (EObjectFlags)GetFlagsInternal();
        checkfSlow((Flags & ~RF_AllFlags) == 0, TEXT("%s flagged as RF_AllFlags"), *GetFName().ToString());
        return Flags;
    }
 
    FORCENOINLINE void AtomicallySetFlags( EObjectFlags FlagsToAdd )
    {
        int32 OldFlags = GetFlagsInternal();
        int32 NewFlags = OldFlags | FlagsToAdd;
 
        // Fast path without atomics if already set
        if (NewFlags == OldFlags)
        {
            return;
        }
 
        UE_AUTORTFM_OPEN
        {
            FPlatformAtomics::InterlockedOr((int32*)&ObjectFlags, FlagsToAdd);
        };
 
        // If we abort we undo setting the flags we just set.
        AutoRTFM::OnAbort([this, OldFlags, FlagsToAdd]
            {
                int32 MaskFlags = OldFlags;
 
                // Now just extract out the old flags that mattered (the ones we were setting).
                MaskFlags &= FlagsToAdd;
                // And unmask the flags we didn't mention.
                MaskFlags |= ~FlagsToAdd;
 
                FPlatformAtomics::InterlockedAnd((int32*)&ObjectFlags, MaskFlags);
            });
    }
 
    FORCENOINLINE void AtomicallyClearFlags( EObjectFlags FlagsToClear )
    {
        int32 OldFlags = GetFlagsInternal();
        int32 NewFlags = OldFlags & ~FlagsToClear;
 
        // Fast path without atomics if already cleared
        if (NewFlags == OldFlags)
        {
            return;
        }
 
        UE_AUTORTFM_OPEN 
        {
            FPlatformAtomics::InterlockedAnd((int32*)&ObjectFlags, ~FlagsToClear);
        };
 
        // If we abort we undo clearing the flags we just unset.
        AutoRTFM::OnAbort([this, OldFlags, FlagsToClear]
            {
                int32 MaskFlags = OldFlags;
 
                // Now just extract out the old flags that mattered (the ones we were setting).
                MaskFlags &= FlagsToClear;
 
                FPlatformAtomics::InterlockedOr((int32*)&ObjectFlags, MaskFlags);
            });
    }
 
    static void PrefetchClass(UObject* Object) { FPlatformMisc::Prefetch(Object, offsetof(UObjectBase, ClassPrivate)); }
    static void PrefetchOuter(UObject* Object) { FPlatformMisc::Prefetch(Object, offsetof(UObjectBase, OuterPrivate)); }
 
private:
    FORCEINLINE int32 GetFlagsInternal() const
    {
        static_assert(sizeof(int32) == sizeof(ObjectFlags), "Flags must be 32-bit for atomics.");
 
        int32 Result = 0;
 
        UE_AUTORTFM_OPEN
        {
            Result = FPlatformAtomics::AtomicRead_Relaxed((int32*)&ObjectFlags);
        };
 
        return Result;
    }
 
    EObjectFlags                    ObjectFlags;
 
    int32                           InternalIndex;
 
    ObjectPtr_Private::TNonAccessTrackedObjectPtr<UClass>                           ClassPrivate;
 
    // Merged data for constinit UObjects to hold their name before the FName system is initialized
    // The object flags RF_MarkAsNative | RF_NeedInitialization are used to assert correct use of this union.
    struct FNameAndObjectHashIndex
    {
        FName Name;
#if UE_STORE_OBJECT_LIST_INTERNAL_INDEX
        int32 ObjectListInternalIndex;
#endif
        constexpr FNameAndObjectHashIndex()
        : Name()
#if UE_STORE_OBJECT_LIST_INTERNAL_INDEX
        , ObjectListInternalIndex(INDEX_NONE)
#endif
        {
        }
        FNameAndObjectHashIndex(ENoInit)
        : Name(NoInit)
        {}
        FNameAndObjectHashIndex(FName InName)
        : Name(InName)
#if UE_STORE_OBJECT_LIST_INTERNAL_INDEX
        , ObjectListInternalIndex(INDEX_NONE)
#endif
        {
        }
    };
    union 
    {
        FNameAndObjectHashIndex NamePrivate = {};
#if UE_WITH_CONSTINIT_UOBJECT
        const UTF8CHAR* UninitializedNameUTF8;
#endif
    };
#if UE_WITH_CONSTINIT_UOBJECT
    static_assert(sizeof(UninitializedNameUTF8) <= sizeof(FNameAndObjectHashIndex), 
        "Wasted space in UObject? If FName is small in this configuration, enable UE_STORE_OBJECT_LIST_INTERNAL_INDEX to speed up the UObject Hash.");
#endif
    
#if UE_WITH_CONSTINIT_UOBJECT
    FName GetUninitializedName()
    {
        if (EnumHasAllFlags(ObjectFlags, RF_MarkAsNative | RF_NeedInitialization))
        {
            FName NewName(UninitializedNameUTF8);
            return NewName;
        }
        checkfSlow(false, TEXT("Compiled-in object unexpectedly already had its name initialized? %s"), *NamePrivate.Name.ToString());
        return FName();
    }
#endif
 
    ObjectPtr_Private::TNonAccessTrackedObjectPtr<UObject>                      OuterPrivate;
    
    friend class FBlueprintCompileReinstancer;
    friend class FVerseObjectClassReplacer;
    friend class FContextObjectManager;
    friend class FDeferredRegistry;
    friend class FCompiledInObjectRegistry;
    friend void AddToClassMap(class FUObjectHashTables& ThreadHash, UObjectBase* Object);
    friend void RemoveFromClassMap(class FUObjectHashTables& ThreadHash, UObjectBase* Object);
 
#if UE_WITH_CONSTINIT_UOBJECT
    void AddConstInitObject();
#endif
 
#if UE_STORE_OBJECT_LIST_INTERNAL_INDEX
    // Internal accessor for internal index to hide gory union/struct details
    inline int32& GetObjectHashInternalIndex() { return NamePrivate.ObjectListInternalIndex; }
#endif
 
#if WITH_EDITOR
    COREUOBJECT_API void SetClass(UClass* NewClass);
#endif
};
 
COREUOBJECT_API bool UObjectInitialized();
 
COREUOBJECT_API void UObjectForceRegistration(UObjectBase* Object, bool bCheckForModuleRelease = true);
 
#if !UE_WITH_CONSTINIT_UOBJECT
template <typename T, typename V>
struct TRegistrationInfo
{
    using TType = T;
    using TVersion = V;
 
    TType* InnerSingleton = nullptr;
    TType* OuterSingleton = nullptr;
    TVersion ReloadVersionInfo;
};
 
struct FClassReloadVersionInfo
{
#if WITH_RELOAD
    SIZE_T Size = 0;
    uint32 Hash = 0;
#endif
};
 
using FClassRegistrationInfo = TRegistrationInfo<UClass, FClassReloadVersionInfo>;
 
struct FClassRegisterCompiledInInfo
{
    class UClass* (*OuterRegister)();
    class UClass* (*InnerRegister)();
    const TCHAR* Name;
    FClassRegistrationInfo* Info;
    FClassReloadVersionInfo VersionInfo;
};
 
COREUOBJECT_API void RegisterCompiledInInfo(class UClass* (*InOuterRegister)(), class UClass* (*InInnerRegister)(), const TCHAR* InPackageName, const TCHAR* InName, FClassRegistrationInfo& InInfo, const FClassReloadVersionInfo& InVersionInfo);
 
struct FStructReloadVersionInfo
{
#if WITH_RELOAD
    SIZE_T Size = 0;
    uint32 Hash = 0;
#endif
};
 
using FStructRegistrationInfo = TRegistrationInfo<UScriptStruct, FStructReloadVersionInfo>;
 
struct FStructRegisterCompiledInInfo
{
    class UScriptStruct* (*OuterRegister)();
    void* (*CreateCppStructOps)();
    const TCHAR* Name;
    FStructRegistrationInfo* Info;
    FStructReloadVersionInfo VersionInfo;
};
 
COREUOBJECT_API void RegisterCompiledInInfo(class UScriptStruct* (*InOuterRegister)(), const TCHAR* InPackageName, const TCHAR* InName, FStructRegistrationInfo& InInfo, const FStructReloadVersionInfo& InVersionInfo);
 
COREUOBJECT_API class UScriptStruct* GetStaticStruct(class UScriptStruct* (*InRegister)(), UObject* StructOuter, const TCHAR* StructName);
 
struct FEnumReloadVersionInfo
{
#if WITH_RELOAD
    uint32 Hash = 0;
#endif
};
 
using FEnumRegistrationInfo = TRegistrationInfo<UEnum, FEnumReloadVersionInfo>;
 
struct FEnumRegisterCompiledInInfo
{
    class UEnum* (*OuterRegister)();
    const TCHAR* Name;
    FEnumRegistrationInfo* Info;
    FEnumReloadVersionInfo VersionInfo;
};
 
COREUOBJECT_API void RegisterCompiledInInfo(class UEnum* (*InOuterRegister)(), const TCHAR* InPackageName, const TCHAR* InName, FEnumRegistrationInfo& InInfo, const FEnumReloadVersionInfo& InVersionInfo);
 
COREUOBJECT_API class UEnum* GetStaticEnum(class UEnum* (*InRegister)(), UObject* EnumOuter, const TCHAR* EnumName);
 
struct FPackageReloadVersionInfo
{
#if WITH_RELOAD
    uint32 BodyHash = 0;
    uint32 DeclarationsHash = 0;
#endif
};
 
using FPackageRegistrationInfo = TRegistrationInfo<UPackage, FPackageReloadVersionInfo>;
 
COREUOBJECT_API void RegisterCompiledInInfo(UPackage* (*InOuterRegister)(), const TCHAR* InPackageName, FPackageRegistrationInfo& InInfo, const FPackageReloadVersionInfo& InVersionInfo);
 
COREUOBJECT_API void RegisterCompiledInInfo(const TCHAR* PackageName, const FClassRegisterCompiledInInfo* ClassInfo, size_t NumClassInfo, const FStructRegisterCompiledInInfo* StructInfo, size_t NumStructInfo, const FEnumRegisterCompiledInInfo* EnumInfo, size_t NumEnumInfo);
 
#endif // !UE_WITH_CONSTINIT_UOBJECT
 
 
COREUOBJECT_API void RegisterModularObjectsProcessing();
 
COREUOBJECT_API void ProcessNewlyLoadedUObjects(FName InModuleName = NAME_None, bool bCanProcessNewlyLoadedObjects = true);
 
#if !UE_WITH_CONSTINIT_UOBJECT
struct FRegisterCompiledInInfo
{
    template <typename... ArgTypes>
    FRegisterCompiledInInfo(ArgTypes&&... Args)
    {
        RegisterCompiledInInfo(Forward<ArgTypes>(Args)...);
    }
};
#endif // !UE_WITH_CONSTINIT_UOBJECT
 
void UObjectBaseInit();
 
void UObjectBaseShutdown();