UObjectHash.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UObjectHash.h: Unreal object name hashes
=============================================================================*/
 
#pragma once
 
#include "Concepts/SameAs.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Stats/Stats.h"
#include "Templates/Function.h"
#include "UObject/FindObjectFlags.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectArray.h"
#include "UObject/UnrealNames.h"
 
class FOutputDevice;
class UClass;
class UObject;
class UPackage;
 
DECLARE_STATS_GROUP_VERBOSE(TEXT("UObject Hash"), STATGROUP_UObjectHash, STATCAT_Advanced);
 
#if !UE_BUILD_TEST && !UE_BUILD_SHIPPING
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("NumObjects"), STAT_Hash_NumObjects, STATGROUP_UObjectHash, COREUOBJECT_API);
#endif // !UE_BUILD_TEST && !UE_BUILD_SHIPPING
 
COREUOBJECT_API UObject* StaticFindObjectFastInternal(const UClass* Class, const UObject* InOuter, FName InName, EFindObjectFlags Flags = EFindObjectFlags::None, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindObjectFastInternal")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObjectFastInternal(const UClass* Class, const UObject* InOuter, FName InName, ExactClassType bExactClass, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None)
{
    return StaticFindObjectFastInternal(Class, InOuter, InName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExclusiveFlags, ExclusiveInternalFlags);
}
 
COREUOBJECT_API bool StaticFindAllObjectsFastInternal(TArray<UObject*>& OutFoundObjects, const UClass* ObjectClass, FName ObjectName, EFindObjectFlags Flags = EFindObjectFlags::None, EObjectFlags ExcludeFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindAllObjectsFastInternal")
UE_NODEBUG UE_FORCEINLINE_HINT bool StaticFindAllObjectsFastInternal(TArray<UObject*>& OutFoundObjects, const UClass* ObjectClass, FName ObjectName, ExactClassType bExactClass, EObjectFlags ExcludeFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None)
{
    return StaticFindAllObjectsFastInternal(OutFoundObjects, ObjectClass, ObjectName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExcludeFlags, ExclusiveInternalFlags);
}
 
COREUOBJECT_API UObject* StaticFindFirstObjectFastInternal(const UClass* ObjectClass, FName ObjectName, EFindObjectFlags Flags = EFindObjectFlags::None, EObjectFlags ExcludeFlag = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindFirstObjectFastInternal")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindFirstObjectFastInternal(const UClass* ObjectClass, FName ObjectName, ExactClassType bExactClass, EObjectFlags ExcludeFlag = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None)
{
    return StaticFindFirstObjectFastInternal(ObjectClass, ObjectName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExcludeFlag, ExclusiveInternalFlags);
}
 
UObject* StaticFindObjectFastExplicit(const UClass* ObjectClass, FName ObjectName, const FString& ObjectPathName, EFindObjectFlags Flags = EFindObjectFlags::None, EObjectFlags ExcludeFlags = RF_NoFlags);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindObjectFastExplicit")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObjectFastExplicit(const UClass* ObjectClass, FName ObjectName, const FString& ObjectPathName, ExactClassType bExactClass, EObjectFlags ExcludeFlags = RF_NoFlags)
{
    return StaticFindObjectFastExplicit(ObjectClass, ObjectName, ObjectPathName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExcludeFlags);
}
 
COREUOBJECT_API UObject* StaticFindObjectFastInternal(FRemoteObjectId RemoteId, EObjectFlags InExclusiveFlags = RF_NoFlags, EInternalObjectFlags InExlusiveInternalFlags = EInternalObjectFlags::None);
 
COREUOBJECT_API void GetObjectsWithOuter(const class UObjectBase* Outer, TArray<UObject *>& Results, bool bIncludeNestedObjects = true, EObjectFlags ExclusionFlags = RF_NoFlags, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);
 
COREUOBJECT_API void ForEachObjectWithOuterBreakable(const class UObjectBase* Outer, TFunctionRef<bool(UObject*)> Operation, bool bIncludeNestedObjects = true, EObjectFlags ExclusionFlags = RF_NoFlags, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);
 
inline void ForEachObjectWithOuter(const class UObjectBase* Outer, TFunctionRef<void(UObject*)> Operation, bool bIncludeNestedObjects = true, EObjectFlags ExclusionFlags = RF_NoFlags, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None)
{
    ForEachObjectWithOuterBreakable(Outer, [Operation](UObject* Object) { Operation(Object); return true; }, bIncludeNestedObjects, ExclusionFlags, ExclusionInternalFlags);
}
 
COREUOBJECT_API class UObjectBase* FindObjectWithOuter(const class UObjectBase* Outer, const class UClass* ClassToLookFor = nullptr, FName NameToLookFor = NAME_None);
 
COREUOBJECT_API void GetObjectsWithPackage(const class UPackage* Outer, TArray<UObject *>& Results, bool bIncludeNestedObjects = true, EObjectFlags ExclusionFlags = RF_NoFlags, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);
 
COREUOBJECT_API void ForEachObjectWithPackage(const class UPackage* Outer, TFunctionRef<bool(UObject*)> Operation, bool bIncludeNestedObjects = true, EObjectFlags ExclusionFlags = RF_NoFlags, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);
 
COREUOBJECT_API void GetObjectsOfClass(const UClass* ClassToLookFor, TArray<UObject *>& Results, bool bIncludeDerivedClasses = true, EObjectFlags ExcludeFlags = RF_ClassDefaultObject, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);
 
COREUOBJECT_API void ForEachObjectOfClass(const UClass* ClassToLookFor, TFunctionRef<void(UObject*)> Operation, bool bIncludeDerivedClasses = true, EObjectFlags ExcludeFlags = RF_ClassDefaultObject, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);
 
COREUOBJECT_API void ForEachObjectOfClasses(TArrayView<const UClass* const> ClassesToLookFor, TFunctionRef<void(UObject*)> Operation, EObjectFlags ExcludeFlags = RF_ClassDefaultObject, EInternalObjectFlags ExclusionInternalFlags = EInternalObjectFlags::None);
 
COREUOBJECT_API void GetDerivedClasses(const UClass* ClassToLookFor, TArray<UClass *>& Results, bool bRecursive = true);
 
COREUOBJECT_API TMap<UClass*, TSet<UClass*>> GetAllDerivedClasses();
 
COREUOBJECT_API bool ClassHasInstancesAsyncLoading(const UClass* ClassToLookFor);
 
void HashObject(class UObjectBase* Object);
void UnhashObject(class UObjectBase* Object);
 
 
void HashObjectExternalPackage(class UObjectBase* Object, class UPackage* Package);
 
void UnhashObjectExternalPackage(class UObjectBase* Object);
 
UPackage* GetObjectExternalPackageThreadSafe(const class UObjectBase* Object);
 
UPackage* GetObjectExternalPackageInternal(const class UObjectBase* Object);
 
COREUOBJECT_API void ShrinkUObjectHashTables();
 
COREUOBJECT_API uint64 GetRegisteredClassesVersionNumber();
 
COREUOBJECT_API uint64 GetRegisteredNativeClassesVersionNumber();
 
COREUOBJECT_API void LogHashStatistics(FOutputDevice& Ar, const bool bShowHashBucketCollisionInfo);
 
COREUOBJECT_API void LogHashOuterStatistics(FOutputDevice& Ar, const bool bShowHashBucketCollisionInfo);
 
enum class EObjectMemoryOverheadOptions
{
    None,
    ShowIndividualStats = 1 << 0,
    IncludeReflectionData = 1 << 1
};
ENUM_CLASS_FLAGS(EObjectMemoryOverheadOptions)
 
 
COREUOBJECT_API void LogHashMemoryOverheadStatistics(FOutputDevice& Ar, const EObjectMemoryOverheadOptions InOptions);
 
UE_DEPRECATED(5.5, "LogHashMemoryOverheadStatistics that takes bool parameter has been deprecated.")
inline void LogHashMemoryOverheadStatistics(FOutputDevice& Ar, const bool bShowIndividualStats)
{
    LogHashMemoryOverheadStatistics(Ar, bShowIndividualStats ? EObjectMemoryOverheadOptions::ShowIndividualStats : EObjectMemoryOverheadOptions::None);
}
 
void LockUObjectHashTables();
void UnlockUObjectHashTables();
 
class FScopedUObjectHashTablesLock
{
public:
    UE_FORCEINLINE_HINT FScopedUObjectHashTablesLock()
    {
        LockUObjectHashTables();
    }
    UE_FORCEINLINE_HINT ~FScopedUObjectHashTablesLock()
    {
        UnlockUObjectHashTables();
    }
};