932 lines
30 KiB
C++
932 lines
30 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
UObjectBaseUtility.h: Unreal UObject functions that only depend on UObjectBase
|
|
=============================================================================*/
|
|
|
|
#pragma once
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Stats/Stats.h"
|
|
#include "UObject/ObjectMacros.h"
|
|
#include "UObject/UObjectBase.h"
|
|
#include "UObject/UObjectArray.h"
|
|
#include "UObject/UObjectMarks.h"
|
|
|
|
#if defined(_MSC_VER) && _MSC_VER == 1900
|
|
#ifdef PRAGMA_DISABLE_SHADOW_VARIABLE_WARNINGS
|
|
PRAGMA_DISABLE_SHADOW_VARIABLE_WARNINGS
|
|
#endif
|
|
#endif
|
|
|
|
/**
|
|
* Enum which specifies the mode in which full object names are constructed
|
|
*/
|
|
enum class EObjectFullNameFlags
|
|
{
|
|
// Standard object full name (i.e. "Type PackageName.ObjectName:SubobjectName")
|
|
None = 0,
|
|
|
|
// Adds package to the type portion (i.e. "TypePackage.TypeName PackageName.ObjectName:SubobjectName")
|
|
IncludeClassPackage = 1,
|
|
};
|
|
|
|
ENUM_CLASS_FLAGS(EObjectFullNameFlags);
|
|
|
|
/**
|
|
* Provides utility functions for UObject, this class should not be used directly
|
|
*/
|
|
class COREUOBJECT_API UObjectBaseUtility: public UObjectBase
|
|
{
|
|
public:
|
|
// Constructors.
|
|
UObjectBaseUtility() {}
|
|
UObjectBaseUtility(EObjectFlags InFlags)
|
|
: UObjectBase(InFlags)
|
|
{
|
|
}
|
|
|
|
/*-------------------
|
|
Flags
|
|
-------------------*/
|
|
|
|
/** Modifies object flags for a specific object */
|
|
FORCEINLINE void SetFlags(EObjectFlags NewFlags)
|
|
{
|
|
checkSlow(!(NewFlags & (RF_MarkAsNative | RF_MarkAsRootSet))); // These flags can't be used outside of constructors / internal code
|
|
SetFlagsTo(GetFlags() | NewFlags);
|
|
}
|
|
|
|
/** Clears subset of flags for a specific object */
|
|
FORCEINLINE void ClearFlags(EObjectFlags NewFlags)
|
|
{
|
|
checkSlow(!(NewFlags & (RF_MarkAsNative | RF_MarkAsRootSet)) || NewFlags == RF_AllFlags); // These flags can't be used outside of constructors / internal code
|
|
SetFlagsTo(GetFlags() & ~NewFlags);
|
|
}
|
|
|
|
/**
|
|
* Used to safely check whether any of the passed in flags are set.
|
|
*
|
|
* @param FlagsToCheck Object flags to check for.
|
|
* @return true if any of the passed in flags are set, false otherwise (including no flags passed in).
|
|
*/
|
|
FORCEINLINE bool HasAnyFlags(EObjectFlags FlagsToCheck) const
|
|
{
|
|
checkSlow(!(FlagsToCheck & (RF_MarkAsNative | RF_MarkAsRootSet)) || FlagsToCheck == RF_AllFlags); // These flags can't be used outside of constructors / internal code
|
|
return (GetFlags() & FlagsToCheck) != 0;
|
|
}
|
|
|
|
/**
|
|
* Used to safely check whether all of the passed in flags are set.
|
|
*
|
|
* @param FlagsToCheck Object flags to check for
|
|
* @return true if all of the passed in flags are set (including no flags passed in), false otherwise
|
|
*/
|
|
FORCEINLINE bool HasAllFlags(EObjectFlags FlagsToCheck) const
|
|
{
|
|
checkSlow(!(FlagsToCheck & (RF_MarkAsNative | RF_MarkAsRootSet)) || FlagsToCheck == RF_AllFlags); // These flags can't be used outside of constructors / internal code
|
|
return ((GetFlags() & FlagsToCheck) == FlagsToCheck);
|
|
}
|
|
|
|
/**
|
|
* Returns object flags that are both in the mask and set on the object.
|
|
*
|
|
* @param Mask Mask to mask object flags with
|
|
* @param Objects flags that are set in both the object and the mask
|
|
*/
|
|
FORCEINLINE EObjectFlags GetMaskedFlags(EObjectFlags Mask = RF_AllFlags) const
|
|
{
|
|
return EObjectFlags(GetFlags() & Mask);
|
|
}
|
|
|
|
/*----------------------------------------------------
|
|
Marks, implemented in UObjectMarks.cpp
|
|
----------------------------------------------------*/
|
|
|
|
/**
|
|
* Adds marks to an object
|
|
*
|
|
* @param Marks Logical OR of OBJECTMARK_'s to apply
|
|
*/
|
|
FORCEINLINE void Mark(EObjectMark Marks) const
|
|
{
|
|
MarkObject(this, Marks);
|
|
}
|
|
|
|
/**
|
|
* Removes marks from and object
|
|
*
|
|
* @param Marks Logical OR of OBJECTMARK_'s to remove
|
|
*/
|
|
FORCEINLINE void UnMark(EObjectMark Marks) const
|
|
{
|
|
UnMarkObject(this, Marks);
|
|
}
|
|
|
|
/**
|
|
* Tests an object for having ANY of a set of marks
|
|
*
|
|
* @param Marks Logical OR of OBJECTMARK_'s to test
|
|
* @return true if the object has any of the given marks.
|
|
*/
|
|
FORCEINLINE bool HasAnyMarks(EObjectMark Marks) const
|
|
{
|
|
return ObjectHasAnyMarks(this, Marks);
|
|
}
|
|
|
|
/**
|
|
* Tests an object for having ALL of a set of marks
|
|
*
|
|
* @param Marks Logical OR of OBJECTMARK_'s to test
|
|
* @return true if the object has any of the given marks.
|
|
*/
|
|
FORCEINLINE bool HasAllMarks(EObjectMark Marks) const
|
|
{
|
|
return ObjectHasAllMarks(this, Marks);
|
|
}
|
|
|
|
/**
|
|
* Returns all of the object marks on a specific object
|
|
*
|
|
* @param Object Object to get marks for
|
|
* @return all Marks for an object
|
|
*/
|
|
FORCEINLINE EObjectMark GetAllMarks() const
|
|
{
|
|
return ObjectGetAllMarks(this);
|
|
}
|
|
|
|
/**
|
|
* Checks the PendingKill flag to see if it is dead but memory still valid
|
|
*/
|
|
FORCEINLINE bool IsPendingKill() const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->IsPendingKill();
|
|
}
|
|
|
|
/**
|
|
* Marks this object as RF_PendingKill.
|
|
*/
|
|
FORCEINLINE void MarkPendingKill()
|
|
{
|
|
check(!IsRooted());
|
|
GUObjectArray.IndexToObject(InternalIndex)->SetPendingKill();
|
|
}
|
|
|
|
/**
|
|
* Unmarks this object as PendingKill.
|
|
*/
|
|
FORCEINLINE void ClearPendingKill()
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->ClearPendingKill();
|
|
}
|
|
|
|
/**
|
|
* Add an object to the root set. This prevents the object and all
|
|
* its descendants from being deleted during garbage collection.
|
|
*/
|
|
FORCEINLINE void AddToRoot()
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->SetRootSet();
|
|
}
|
|
|
|
/** Remove an object from the root set. */
|
|
FORCEINLINE void RemoveFromRoot()
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->ClearRootSet();
|
|
}
|
|
|
|
/**
|
|
* Returns true if this object is explicitly rooted
|
|
*
|
|
* @return true if the object was explicitly added as part of the root set.
|
|
*/
|
|
FORCEINLINE bool IsRooted() const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->IsRootSet();
|
|
}
|
|
|
|
/**
|
|
* Atomically clear the unreachable flag
|
|
*
|
|
* @return true if we are the thread that cleared RF_Unreachable
|
|
*/
|
|
FORCEINLINE bool ThisThreadAtomicallyClearedRFUnreachable()
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->ThisThreadAtomicallyClearedRFUnreachable();
|
|
}
|
|
|
|
/** Checks if the object is unreachable. */
|
|
FORCEINLINE bool IsUnreachable() const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->IsUnreachable();
|
|
}
|
|
|
|
/** Checks if the object is pending kill or unreachable. */
|
|
FORCEINLINE bool IsPendingKillOrUnreachable() const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->HasAnyFlags(EInternalObjectFlags::PendingKill | EInternalObjectFlags::Unreachable);
|
|
}
|
|
|
|
/** Checks if the object is native. */
|
|
FORCEINLINE bool IsNative() const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->HasAnyFlags(EInternalObjectFlags::Native);
|
|
}
|
|
|
|
/**
|
|
* Clears passed in internal flags.
|
|
*
|
|
* @param FlagsToClear Object flags to clear.
|
|
* @return true if any of the passed in flags are set, false otherwise (including no flags passed in).
|
|
*/
|
|
FORCEINLINE void SetInternalFlags(EInternalObjectFlags FlagsToSet) const
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->SetFlags(FlagsToSet);
|
|
}
|
|
|
|
/**
|
|
* Gets internal flags.
|
|
*
|
|
* @param FlagsToClear Object flags to clear.
|
|
* @return true if any of the passed in flags are set, false otherwise (including no flags passed in).
|
|
*/
|
|
FORCEINLINE EInternalObjectFlags GetInternalFlags() const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->GetFlags();
|
|
}
|
|
|
|
/**
|
|
* Used to safely check whether any of the passed in internal flags are set.
|
|
*
|
|
* @param FlagsToCheck Object flags to check for.
|
|
* @return true if any of the passed in flags are set, false otherwise (including no flags passed in).
|
|
*/
|
|
FORCEINLINE bool HasAnyInternalFlags(EInternalObjectFlags FlagsToCheck) const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->HasAnyFlags(FlagsToCheck);
|
|
}
|
|
|
|
/**
|
|
* Clears passed in internal flags.
|
|
*
|
|
* @param FlagsToClear Object flags to clear.
|
|
* @return true if any of the passed in flags are set, false otherwise (including no flags passed in).
|
|
*/
|
|
FORCEINLINE void ClearInternalFlags(EInternalObjectFlags FlagsToClear) const
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->ClearFlags(FlagsToClear);
|
|
}
|
|
|
|
/**
|
|
* Atomically clears passed in internal flags.
|
|
*
|
|
* @param FlagsToClear Object flags to clear.
|
|
* @return true if any of the passed in flags are set, false otherwise (including no flags passed in).
|
|
*/
|
|
FORCEINLINE bool AtomicallyClearInternalFlags(EInternalObjectFlags FlagsToClear) const
|
|
{
|
|
return GUObjectArray.IndexToObject(InternalIndex)->ThisThreadAtomicallyClearedFlag(FlagsToClear);
|
|
}
|
|
|
|
/*-------------------
|
|
Names
|
|
-------------------*/
|
|
|
|
/**
|
|
* Returns the fully qualified pathname for this object as well as the name of the class, in the format:
|
|
* 'ClassName Outermost[.Outer].Name'.
|
|
*
|
|
* @param StopOuter if specified, indicates that the output string should be relative to this object. if StopOuter
|
|
* does not exist in this object's Outer chain, the result would be the same as passing NULL.
|
|
* @param Flags flags that control the behavior of full name generation
|
|
*
|
|
* @note safe to call on NULL object pointers!
|
|
*/
|
|
FString GetFullName(const UObject* StopOuter = NULL, EObjectFullNameFlags Flags = EObjectFullNameFlags::None) const;
|
|
|
|
/**
|
|
* Version of GetFullName() that eliminates unnecessary copies.
|
|
*/
|
|
void GetFullName(const UObject* StopOuter, FString& ResultString, EObjectFullNameFlags Flags = EObjectFullNameFlags::None) const;
|
|
|
|
/**
|
|
* Returns the fully qualified pathname for this object, in the format:
|
|
* 'Outermost[.Outer].Name'
|
|
*
|
|
* @param StopOuter if specified, indicates that the output string should be relative to this object. if StopOuter
|
|
* does not exist in this object's Outer chain, the result would be the same as passing NULL.
|
|
*
|
|
* @note safe to call on NULL object pointers!
|
|
*/
|
|
FString GetPathName(const UObject* StopOuter = NULL) const;
|
|
|
|
/**
|
|
* Versions of GetPathName() that eliminates unnecessary copies and allocations.
|
|
*/
|
|
void GetPathName(const UObject* StopOuter, FString& ResultString) const;
|
|
void GetPathName(const UObject* StopOuter, FStringBuilderBase& ResultString) const;
|
|
|
|
public:
|
|
/**
|
|
* Called after load to determine if the object can be a cluster root
|
|
*
|
|
* @return true if this object can be a cluster root
|
|
*/
|
|
virtual bool CanBeClusterRoot() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Called during cluster construction if the object can be added to a cluster
|
|
*
|
|
* @return true if this object can be inside of a cluster
|
|
*/
|
|
virtual bool CanBeInCluster() const;
|
|
|
|
/**
|
|
* Called after PostLoad to create UObject cluster
|
|
*/
|
|
virtual void CreateCluster();
|
|
|
|
/**
|
|
* Called during Garbage Collection to perform additional cleanup when the cluster is about to be destroyed due to PendingKill flag being set on it.
|
|
*/
|
|
virtual void OnClusterMarkedAsPendingKill() {}
|
|
|
|
/**
|
|
* Adds this objects to a GC cluster that already exists
|
|
* @param ClusterRootOrObjectFromCluster Object that belongs to the cluster we want to add this object to.
|
|
* @param Add this object to the target cluster as a mutable object without adding this object's references.
|
|
*/
|
|
void AddToCluster(UObjectBaseUtility* ClusterRootOrObjectFromCluster, bool bAddAsMutableObject = false);
|
|
|
|
protected:
|
|
/** Helper function to create a cluster from UObject */
|
|
static void CreateClusterFromObject(UObjectBaseUtility* ClusterRootObject, UObjectBaseUtility* ReferencingObject);
|
|
|
|
public:
|
|
/**
|
|
* Walks up the chain of packages until it reaches the top level, which it ignores.
|
|
*
|
|
* @param bStartWithOuter whether to include this object's name in the returned string
|
|
* @return string containing the path name for this object, minus the outermost-package's name
|
|
*/
|
|
FString GetFullGroupName(bool bStartWithOuter) const;
|
|
|
|
/**
|
|
* Returns the name of this object (with no path information)
|
|
*
|
|
* @return Name of the object.
|
|
*/
|
|
FORCEINLINE FString GetName() const
|
|
{
|
|
return GetFName().ToString();
|
|
}
|
|
|
|
/** Optimized version of GetName that overwrites an existing string */
|
|
FORCEINLINE void GetName(FString& ResultString) const
|
|
{
|
|
GetFName().ToString(ResultString);
|
|
}
|
|
/** Optimized version of GetName that appends to an existing string */
|
|
FORCEINLINE void AppendName(FString& ResultString) const
|
|
{
|
|
GetFName().AppendString(ResultString);
|
|
}
|
|
|
|
/*-------------------
|
|
Outer & Package
|
|
-------------------*/
|
|
|
|
/**
|
|
* Utility function to temporarily detach the object external package, if any
|
|
* GetPackage will report the outer's package once detached
|
|
*/
|
|
void DetachExternalPackage();
|
|
|
|
/**
|
|
* Utility function to reattach the object external package, if any
|
|
* GetPackage will report the object external package if set after this call
|
|
*/
|
|
void ReattachExternalPackage();
|
|
|
|
/**
|
|
* Walks up the list of outers until it finds the top-level one that isn't a package.
|
|
* Will return null if called on a package
|
|
* @return outermost non package Outer.
|
|
*/
|
|
UObject* GetOutermostObject() const;
|
|
|
|
/**
|
|
* Walks up the list of outers until it finds a package directly associated with the object.
|
|
*
|
|
* @return the package the object is in.
|
|
*/
|
|
UPackage* GetPackage() const;
|
|
|
|
/**
|
|
* Legacy function, has the same behavior as GetPackage
|
|
* use GetPackage instead.
|
|
* @return the package the object is in.
|
|
* @see GetPackage
|
|
*/
|
|
UPackage* GetOutermost() const;
|
|
|
|
/**
|
|
* Finds the outermost package and marks it dirty.
|
|
* The editor suppresses this behavior during load as it is against policy to dirty packages simply by loading them.
|
|
*
|
|
* @return false if the request to mark the package dirty was suppressed by the editor and true otherwise.
|
|
*/
|
|
bool MarkPackageDirty() const;
|
|
|
|
/**
|
|
* Determines whether this object is a template object
|
|
*
|
|
* @return true if this object is a template object (owned by a UClass)
|
|
*/
|
|
bool IsTemplate(EObjectFlags TemplateTypes = RF_ArchetypeObject | RF_ClassDefaultObject) const;
|
|
|
|
/**
|
|
* Traverses the outer chain searching for the next object of a certain type. (T must be derived from UObject)
|
|
*
|
|
* @param Target class to search for
|
|
* @return a pointer to the first object in this object's Outer chain which is of the correct type.
|
|
*/
|
|
UObject* GetTypedOuter(UClass* Target) const;
|
|
|
|
/**
|
|
* Traverses the outer chain searching for the next object of a certain type. (T must be derived from UObject)
|
|
*
|
|
* @return a pointer to the first object in this object's Outer chain which is of the correct type.
|
|
*/
|
|
template <typename T>
|
|
T* GetTypedOuter() const
|
|
{
|
|
return (T*)GetTypedOuter(T::StaticClass());
|
|
}
|
|
|
|
/**
|
|
* Return the dispatch to `IsInOuter` or `IsInPackage` depending on SomeOuter's class.
|
|
* Legacy function, preferably use IsInOuter or IsInPackage depending on use case.
|
|
*/
|
|
bool IsIn(const UObject* SomeOuter) const;
|
|
|
|
/**
|
|
* Overload to determine if an object is in the specified package which can now be different than its outer chain.
|
|
* Calls IsInPackage.
|
|
*/
|
|
bool IsIn(const UPackage* SomePackage) const;
|
|
|
|
/** Returns true if the object is contained in the specified outer. */
|
|
bool IsInOuter(const UObject* SomeOuter) const;
|
|
|
|
/** Returns true if the object is contained in the specified package. */
|
|
bool IsInPackage(const UPackage* SomePackage) const;
|
|
|
|
/**
|
|
* Find out if this object is inside (has an outer) that is of the specified class
|
|
* @param SomeBaseClass The base class to compare against
|
|
* @return True if this object is in an object of the given type.
|
|
*/
|
|
bool IsInA(const UClass* SomeBaseClass) const;
|
|
|
|
/**
|
|
* Checks whether this object's top-most package has any of the specified flags
|
|
*
|
|
* @param CheckFlagMask a bitmask of EPackageFlags values to check for
|
|
*
|
|
* @return true if the PackageFlags member of this object's top-package has any bits from the mask set.
|
|
*/
|
|
bool RootPackageHasAnyFlags(uint32 CheckFlagMask) const;
|
|
|
|
/*-------------------
|
|
Class
|
|
-------------------*/
|
|
|
|
private:
|
|
template <typename ClassType>
|
|
static FORCEINLINE bool IsChildOfWorkaround(const ClassType* ObjClass, const ClassType* TestCls)
|
|
{
|
|
return ObjClass->IsChildOf(TestCls);
|
|
}
|
|
|
|
public:
|
|
/** Returns true if this object is of the specified type. */
|
|
template <typename OtherClassType>
|
|
FORCEINLINE bool IsA(OtherClassType SomeBase) const
|
|
{
|
|
// We have a cyclic dependency between UObjectBaseUtility 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;
|
|
checkfSlow(SomeBaseClass, TEXT("IsA(NULL) cannot yield meaningful results"));
|
|
|
|
const UClass* ThisClass = GetClass();
|
|
|
|
// Stop the compiler doing some unnecessary branching for nullptr checks
|
|
UE_ASSUME(SomeBaseClass);
|
|
UE_ASSUME(ThisClass);
|
|
|
|
return IsChildOfWorkaround(ThisClass, SomeBaseClass);
|
|
}
|
|
|
|
/** Returns true if this object is of the template type. */
|
|
template <class T>
|
|
bool IsA() const
|
|
{
|
|
return IsA(T::StaticClass());
|
|
}
|
|
|
|
/**
|
|
* Finds the most-derived class which is a parent of both TestClass and this object's class.
|
|
*
|
|
* @param TestClass the class to find the common base for
|
|
*/
|
|
const UClass* FindNearestCommonBaseClass(const UClass* TestClass) const;
|
|
|
|
/**
|
|
* Returns a pointer to this object safely converted to a pointer of the specified interface class.
|
|
*
|
|
* @param InterfaceClass the interface class to use for the returned type
|
|
*
|
|
* @return a pointer that can be assigned to a variable of the interface type specified, or NULL if this object's
|
|
* class doesn't implement the interface indicated. Will be the same value as 'this' if the interface class
|
|
* isn't native.
|
|
*/
|
|
void* GetInterfaceAddress(UClass* InterfaceClass);
|
|
|
|
/**
|
|
* Returns a pointer to the I* native interface object that this object implements.
|
|
* Returns NULL if this object does not implement InterfaceClass, or does not do so natively.
|
|
*/
|
|
void* GetNativeInterfaceAddress(UClass* InterfaceClass);
|
|
|
|
/**
|
|
* Returns a pointer to the const I* native interface object that this object implements.
|
|
* Returns NULL if this object does not implement InterfaceClass, or does not do so natively.
|
|
*/
|
|
const void* GetNativeInterfaceAddress(UClass* InterfaceClass) const
|
|
{
|
|
return const_cast<UObjectBaseUtility*>(this)->GetNativeInterfaceAddress(InterfaceClass);
|
|
}
|
|
|
|
/**
|
|
* Returns whether this component was instanced from a component/subobject template, or if it is a component/subobject template.
|
|
* This is based on a name comparison with the outer class instance lookup table
|
|
*
|
|
* @return true if this component was instanced from a template. false if this component was created manually at runtime.
|
|
*/
|
|
bool IsDefaultSubobject() const;
|
|
|
|
/*--------------------------------------------------
|
|
Linker, defined in UObjectLinker.cpp
|
|
--------------------------------------------------*/
|
|
|
|
/**
|
|
* Returns the linker for this object.
|
|
*
|
|
* @return a pointer to the linker for this object, or NULL if this object has no linker
|
|
*/
|
|
class FLinkerLoad* GetLinker() const;
|
|
|
|
/**
|
|
* Returns this object's LinkerIndex.
|
|
*
|
|
* @return the index into my linker's ExportMap for the FObjectExport
|
|
* corresponding to this object.
|
|
*/
|
|
int32 GetLinkerIndex() const;
|
|
|
|
/**
|
|
* Returns the UE4 version of the linker for this object.
|
|
*
|
|
* @return the UE4 version of the engine's package file when this object
|
|
* was last saved, or GPackageFileUE4Version (current version) if
|
|
* this object does not have a linker, which indicates that
|
|
* a) this object is a native only class, or
|
|
* b) this object's linker has been detached, in which case it is already fully loaded
|
|
*/
|
|
int32 GetLinkerUE4Version() const;
|
|
|
|
/**
|
|
* Returns the licensee version of the linker for this object.
|
|
*
|
|
* @return the licensee version of the engine's package file when this object
|
|
* was last saved, or GPackageFileLicenseeVersion (current version) if
|
|
* this object does not have a linker, which indicates that
|
|
* a) this object is a native only class, or
|
|
* b) this object's linker has been detached, in which case it is already fully loaded
|
|
*/
|
|
int32 GetLinkerLicenseeUE4Version() const;
|
|
|
|
/**
|
|
* Returns the custom version of the linker for this object corresponding to the given custom version key.
|
|
*
|
|
* @return the custom version of the engine's package file when this object
|
|
* was last saved, or the current version if
|
|
* this object does not have a linker, which indicates that
|
|
* a) this object is a native only class, or
|
|
* b) this object's linker has been detached, in which case it is already fully loaded
|
|
*/
|
|
int32 GetLinkerCustomVersion(FGuid CustomVersionKey) const;
|
|
|
|
/**
|
|
* Overloaded < operator. Compares objects by name.
|
|
*
|
|
* @return true if this object's name is lexicographically smaller than the other object's name
|
|
*/
|
|
FORCEINLINE bool operator<(const UObjectBaseUtility& Other) const
|
|
{
|
|
return GetName() < Other.GetName();
|
|
}
|
|
|
|
/*******
|
|
* Stats
|
|
*******/
|
|
#if STATS || ENABLE_STATNAMEDEVENTS_UOBJECT
|
|
FORCEINLINE void ResetStatID()
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->StatID = TStatId();
|
|
#if ENABLE_STATNAMEDEVENTS_UOBJECT
|
|
GUObjectArray.IndexToObject(InternalIndex)->StatIDStringStorage = nullptr;
|
|
#endif
|
|
}
|
|
#endif
|
|
/**
|
|
* Returns the stat ID of the object, used for profiling. This will create a stat ID if needed.
|
|
*
|
|
* @param bForDeferred If true, a stat ID will be created even if a group is disabled
|
|
*/
|
|
FORCEINLINE TStatId GetStatID(bool bForDeferredUse = false) const
|
|
{
|
|
#if STATS
|
|
const TStatId& StatID = GUObjectArray.IndexToObject(InternalIndex)->StatID;
|
|
|
|
// this is done to avoid even registering stats for a disabled group (unless we plan on using it later)
|
|
if (bForDeferredUse || FThreadStats::IsCollectingData(GET_STATID(STAT_UObjectsStatGroupTester)))
|
|
{
|
|
if (!StatID.IsValidStat())
|
|
{
|
|
CreateStatID();
|
|
}
|
|
return StatID;
|
|
}
|
|
#elif ENABLE_STATNAMEDEVENTS_UOBJECT
|
|
const TStatId& StatID = GUObjectArray.IndexToObject(InternalIndex)->StatID;
|
|
if (!StatID.IsValidStat() && (bForDeferredUse || GCycleStatsShouldEmitNamedEvents))
|
|
{
|
|
CreateStatID();
|
|
}
|
|
return StatID;
|
|
#endif // STATS
|
|
return TStatId(); // not doing stats at the moment, or ever
|
|
}
|
|
|
|
private:
|
|
#if STATS || ENABLE_STATNAMEDEVENTS_UOBJECT
|
|
/** Creates a stat ID for this object */
|
|
void CreateStatID() const
|
|
{
|
|
GUObjectArray.IndexToObject(InternalIndex)->CreateStatID();
|
|
}
|
|
#endif
|
|
};
|
|
|
|
/** Returns false if this pointer cannot be a valid pointer to a UObject */
|
|
FORCEINLINE bool IsPossiblyAllocatedUObjectPointer(UObject* Ptr)
|
|
{
|
|
auto CountByteValues = [](UPTRINT Val, UPTRINT ByteVal) -> int32
|
|
{
|
|
int32 Result = 0;
|
|
|
|
for (int32 I = 0; I != sizeof(UPTRINT); ++I)
|
|
{
|
|
if ((Val & 0xFF) == ByteVal)
|
|
{
|
|
++Result;
|
|
}
|
|
Val >>= 8;
|
|
}
|
|
|
|
return Result;
|
|
};
|
|
|
|
UPTRINT PtrVal = (UPTRINT)Ptr;
|
|
return PtrVal >= 0x1000 && CountByteValues(PtrVal, 0xCD) < sizeof(UPTRINT) / 2;
|
|
}
|
|
|
|
/**
|
|
* Returns the name of this object (with no path information)
|
|
* @param Object object to retrieve the name for; NULL gives "None"
|
|
* @return Name of the object.
|
|
*/
|
|
FORCEINLINE FString GetNameSafe(const UObjectBaseUtility* Object)
|
|
{
|
|
if (Object == NULL)
|
|
{
|
|
return TEXT("None");
|
|
}
|
|
else
|
|
{
|
|
return Object->GetName();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the path name of this object
|
|
* @param Object object to retrieve the path name for; NULL gives "None"
|
|
* @return path name of the object.
|
|
*/
|
|
FORCEINLINE FString GetPathNameSafe(const UObjectBaseUtility* Object)
|
|
{
|
|
if (Object == NULL)
|
|
{
|
|
return TEXT("None");
|
|
}
|
|
else
|
|
{
|
|
return Object->GetPathName();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the full name of this object
|
|
* @param Object object to retrieve the full name for; NULL (or a null class!) gives "None"
|
|
* @return full name of the object.
|
|
*/
|
|
FORCEINLINE FString GetFullNameSafe(const UObjectBaseUtility* Object)
|
|
{
|
|
if (!Object || !Object->GetClass())
|
|
{
|
|
return TEXT("None");
|
|
}
|
|
else
|
|
{
|
|
return Object->GetFullName();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the native (C++) parent class of the supplied class
|
|
* If supplied class is native, it will be returned.
|
|
*/
|
|
COREUOBJECT_API UClass* GetParentNativeClass(UClass* Class);
|
|
|
|
#if !defined(USE_LIGHTWEIGHT_UOBJECT_STATS_FOR_HITCH_DETECTION)
|
|
#define USE_LIGHTWEIGHT_UOBJECT_STATS_FOR_HITCH_DETECTION (1)
|
|
#endif
|
|
|
|
#if STATS
|
|
|
|
/** Structure used to track time spent by a UObject */
|
|
class FScopeCycleCounterUObject: public FCycleCounter
|
|
{
|
|
public:
|
|
#if USE_MALLOC_PROFILER
|
|
/** Package path being tracked */
|
|
FName PackageTag;
|
|
/** Class path being tracked */
|
|
FName ClassTag;
|
|
/** Object path being tracked */
|
|
FName ObjectTag;
|
|
#endif
|
|
|
|
/**
|
|
* Constructor, starts timing
|
|
*/
|
|
FORCEINLINE_STATS FScopeCycleCounterUObject(const UObjectBaseUtility* Object)
|
|
{
|
|
if (Object)
|
|
{
|
|
TStatId ObjectStatId = Object->GetStatID();
|
|
if (FThreadStats::IsCollectingData(ObjectStatId))
|
|
{
|
|
Start(ObjectStatId);
|
|
}
|
|
}
|
|
|
|
#if USE_MALLOC_PROFILER
|
|
if (Object)
|
|
{
|
|
TrackObjectForMallocProfiling(Object);
|
|
}
|
|
#endif
|
|
}
|
|
/**
|
|
* Constructor, starts timing with an alternate enable stat to use high performance disable for only SOME UObject stats
|
|
*/
|
|
FORCEINLINE_STATS FScopeCycleCounterUObject(const UObjectBaseUtility* Object, TStatId OtherStat)
|
|
{
|
|
if (FThreadStats::IsCollectingData(OtherStat) && Object)
|
|
{
|
|
TStatId ObjectStatId = Object->GetStatID();
|
|
if (!ObjectStatId.IsNone())
|
|
{
|
|
Start(ObjectStatId);
|
|
}
|
|
}
|
|
|
|
#if USE_MALLOC_PROFILER
|
|
if (Object)
|
|
{
|
|
TrackObjectForMallocProfiling(Object);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* Updates the stat with the time spent
|
|
*/
|
|
FORCEINLINE_STATS ~FScopeCycleCounterUObject()
|
|
{
|
|
Stop();
|
|
|
|
#if USE_MALLOC_PROFILER
|
|
UntrackObjectForMallocProfiling();
|
|
#endif
|
|
}
|
|
|
|
#if USE_MALLOC_PROFILER
|
|
COREUOBJECT_API void TrackObjectForMallocProfiling(const UObjectBaseUtility* InObject);
|
|
COREUOBJECT_API void TrackObjectForMallocProfiling(const FName InPackageName, const FName InClassName, const FName InObjectName);
|
|
COREUOBJECT_API void UntrackObjectForMallocProfiling();
|
|
#endif
|
|
};
|
|
|
|
/** Declares a scope cycle counter for a specific object with a Name context */
|
|
#define SCOPE_CYCLE_UOBJECT(Name, Object) \
|
|
FScopeCycleCounterUObject ObjCycleCount_##Name(Object);
|
|
|
|
#elif ENABLE_STATNAMEDEVENTS
|
|
|
|
class FScopeCycleCounterUObject
|
|
{
|
|
public:
|
|
FScopeCycleCounter ScopeCycleCounter;
|
|
FORCEINLINE_STATS FScopeCycleCounterUObject(const UObjectBaseUtility* Object)
|
|
: ScopeCycleCounter(Object ? Object -> GetStatID().StatString : nullptr)
|
|
{
|
|
}
|
|
FORCEINLINE_STATS FScopeCycleCounterUObject(const UObjectBaseUtility* Object, TStatId OtherStat)
|
|
: ScopeCycleCounter(Object ? Object -> GetStatID().StatString : nullptr)
|
|
{
|
|
}
|
|
};
|
|
|
|
/** Declares a scope cycle counter for a specific object with a Name context */
|
|
#define SCOPE_CYCLE_UOBJECT(Name, Object) \
|
|
FScopeCycleCounterUObject ObjCycleCount_##Name(Object);
|
|
#elif USE_LIGHTWEIGHT_STATS_FOR_HITCH_DETECTION && USE_HITCH_DETECTION && USE_LIGHTWEIGHT_UOBJECT_STATS_FOR_HITCH_DETECTION
|
|
extern CORE_API bool GHitchDetected;
|
|
|
|
class FScopeCycleCounterUObject
|
|
{
|
|
const UObject* StatObject;
|
|
|
|
public:
|
|
FORCEINLINE FScopeCycleCounterUObject(const UObject* InStatObject, TStatId OtherStat = TStatId())
|
|
{
|
|
StatObject = GHitchDetected ? nullptr : InStatObject;
|
|
}
|
|
|
|
FORCEINLINE ~FScopeCycleCounterUObject()
|
|
{
|
|
if (GHitchDetected && StatObject)
|
|
{
|
|
ReportHitch();
|
|
}
|
|
}
|
|
|
|
COREUOBJECT_API void ReportHitch();
|
|
};
|
|
|
|
/** Declares a scope cycle counter for a specific object with a Name context */
|
|
#define SCOPE_CYCLE_UOBJECT(Name, Object) \
|
|
FScopeCycleCounterUObject ObjCycleCount_##Name(Object);
|
|
#else
|
|
class FScopeCycleCounterUObject
|
|
{
|
|
public:
|
|
FORCEINLINE_STATS FScopeCycleCounterUObject(const UObjectBaseUtility* Object)
|
|
{
|
|
}
|
|
FORCEINLINE_STATS FScopeCycleCounterUObject(const UObjectBaseUtility* Object, TStatId OtherStat)
|
|
{
|
|
}
|
|
};
|
|
|
|
#define SCOPE_CYCLE_UOBJECT(Name, Object)
|
|
|
|
#endif
|
|
|
|
#if defined(_MSC_VER) && _MSC_VER == 1900
|
|
#ifdef PRAGMA_ENABLE_SHADOW_VARIABLE_WARNINGS
|
|
PRAGMA_ENABLE_SHADOW_VARIABLE_WARNINGS
|
|
#endif
|
|
#endif
|