UObjectBaseUtility.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UObjectBaseUtility.h: Unreal UObject functions that only depend on UObjectBase
=============================================================================*/
 
#pragma once
 
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "Containers/VersePathFwd.h"
#include "HAL/PlatformMath.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "ProfilingDebugging/CpuProfilerTrace.h"
#include "Stats/Stats.h"
#include "Stats/StatsCommon.h"
#include "Trace/Detail/Channel.h"
#include "Trace/Detail/Channel.inl"
#include "Trace/Trace.h"
#include "UObject/GarbageCollectionGlobals.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectVersion.h"
#include "UObject/UObjectArray.h"
#include "UObject/UObjectBase.h"
#include "UObject/UObjectMarks.h"
#include "UObject/ObjectFwd.h"
#include "AutoRTFM.h"
 
class UClass;
class UObject;
class UPackage;
struct FGuid;
 
#if defined(_MSC_VER) && _MSC_VER == 1900
    #ifdef PRAGMA_DISABLE_SHADOW_VARIABLE_WARNINGS
        PRAGMA_DISABLE_SHADOW_VARIABLE_WARNINGS
    #endif
#endif
 
class UObjectBaseUtility : public UObjectBase
{
    static COREUOBJECT_API bool bGarbageEliminationEnabled;
 
    friend void InitGarbageElimination();
    friend struct FInternalUObjectBaseUtilityIsValidFlagsChecker;
 
public:
    // Constructors.
    UObjectBaseUtility() {}
    UObjectBaseUtility( EObjectFlags InFlags )
        : UObjectBase(InFlags)
    {
    }
 
#if UE_WITH_CONSTINIT_UOBJECT
    explicit consteval UObjectBaseUtility(UE::CodeGen::ConstInit::FObjectParams InParams)
    : UObjectBase(InParams)
    {
    }
#endif
 
    /*-------------------
            Flags
    -------------------*/
 
    inline void SetFlags( EObjectFlags NewFlags )
    {
        checkSlow(!(NewFlags & (RF_MarkAsNative | RF_MarkAsRootSet | RF_MirroredGarbage))); // These flags can't be used outside of constructors / internal code
        checkf(!(NewFlags & RF_MirroredGarbage) || (GetFlags() & (NewFlags & RF_MirroredGarbage)) == (NewFlags & RF_MirroredGarbage), TEXT("RF_MirroredGarbage can not be set through SetFlags function. Use MarkAsGarbage() instead"));
        AtomicallySetFlags(NewFlags);
    }
 
    inline void ClearFlags( EObjectFlags FlagsToClear )
    {
        checkSlow(!(FlagsToClear & (RF_MarkAsNative | RF_MarkAsRootSet | RF_MirroredGarbage)) || FlagsToClear == RF_AllFlags); // These flags can't be used outside of constructors / internal code
        checkf(!(FlagsToClear & RF_MirroredGarbage) || (GetFlags() & (FlagsToClear & RF_MirroredGarbage)) == RF_NoFlags, TEXT("RF_MirroredGarbage can not be cleared through ClearFlags function. Use ClearGarbage() instead"));
        AtomicallyClearFlags(FlagsToClear);
    }
 
    inline 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;
    }
 
    inline 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);
    }
 
    UE_FORCEINLINE_HINT EObjectFlags GetMaskedFlags( EObjectFlags Mask = RF_AllFlags ) const
    {
        return EObjectFlags(GetFlags() & Mask);
    }
 
    /*----------------------------------------------------
            Marks, implemented in UObjectMarks.cpp
    ----------------------------------------------------*/
 
    UE_FORCEINLINE_HINT void Mark(EObjectMark Marks) const
    {
        MarkObject(this,Marks);
    }
 
    UE_FORCEINLINE_HINT void UnMark(EObjectMark Marks) const
    {
        UnMarkObject(this,Marks);
    }
 
    UE_FORCEINLINE_HINT bool HasAnyMarks(EObjectMark Marks) const
    {
        return ObjectHasAnyMarks(this,Marks);
    }
 
    UE_FORCEINLINE_HINT bool HasAllMarks(EObjectMark Marks) const
    {
        return ObjectHasAllMarks(this,Marks);
    }
 
    UE_FORCEINLINE_HINT EObjectMark GetAllMarks() const
    {
        return ObjectGetAllMarks(this);
    }
 
    inline void MarkAsGarbage()
    {
        check(!IsRooted());
 
        AtomicallySetFlags(RF_MirroredGarbage);
        GUObjectArray.IndexToObject(InternalIndex)->SetGarbage();
 
        // If we explicitly marked the object as garbage, remove the async flag so it's visible to the GC
        AtomicallyClearInternalFlags(EInternalObjectFlags::Async);
    }
 
    inline void ClearGarbage()
    {
        AtomicallyClearFlags(RF_MirroredGarbage);
        GUObjectArray.IndexToObject(InternalIndex)->ClearGarbage();
    }
 
    UE_FORCEINLINE_HINT void AddToRoot()
    {
        GUObjectArray.IndexToObject(InternalIndex)->SetRootSet();
    }
 
    UE_FORCEINLINE_HINT void RemoveFromRoot()
    {
        GUObjectArray.IndexToObject(InternalIndex)->ClearRootSet();
    }
 
    UE_FORCEINLINE_HINT bool IsRooted() const
    {
        return GUObjectArray.IndexToObject(InternalIndex)->IsRootSet();
    }
 
    UE_FORCEINLINE_HINT int32 GetRefCount() const
    {
        return GUObjectArray.IndexToObject(InternalIndex)->GetRefCount();
    }
 
    UE_DEPRECATED(5.5, "ThisThreadAtomicallyClearedRFUnreachable() should no longer be used. Reachability flags can only be modified by the garbage collector.")
    bool ThisThreadAtomicallyClearedRFUnreachable();
 
    UE_FORCEINLINE_HINT bool IsUnreachable() const
    {
        return GUObjectArray.IndexToObject(InternalIndex)->IsUnreachable();
    }
 
    UE_FORCEINLINE_HINT bool IsNative() const
    {
        return GUObjectArray.IndexToObject(InternalIndex)->HasAnyFlags(EInternalObjectFlags::Native);
    }
 
    inline void SetInternalFlags(EInternalObjectFlags FlagsToSet) const
    {
        FUObjectItem* ObjectItem = GUObjectArray.IndexToObject(InternalIndex);
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        checkf(!(FlagsToSet & EInternalObjectFlags::Garbage) || (FlagsToSet & EInternalObjectFlags::Garbage) == (ObjectItem->GetFlags() & EInternalObjectFlags::Garbage), TEXT("SetInternalFlags should not set the Garbage flag. Use MarkAsGarbage instead"));
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        ObjectItem->SetFlags(FlagsToSet);
    }
 
    UE_FORCEINLINE_HINT EInternalObjectFlags GetInternalFlags() const
    {
        return GUObjectArray.IndexToObject(InternalIndex)->GetFlags();
    }
 
    UE_FORCEINLINE_HINT bool HasAnyInternalFlags(EInternalObjectFlags FlagsToCheck) const
    {
        return GUObjectArray.IndexToObject(InternalIndex)->HasAnyFlags(FlagsToCheck);
    }
 
    inline void ClearInternalFlags(EInternalObjectFlags FlagsToClear) const
    {
        FUObjectItem* ObjectItem = GUObjectArray.IndexToObject(InternalIndex);
        checkf(!(FlagsToClear & EInternalObjectFlags::Garbage) || (ObjectItem->GetFlags() & (FlagsToClear & EInternalObjectFlags::Garbage)) == EInternalObjectFlags::None, TEXT("ClearInternalFlags should not clear Garbage flag. Use ClearGarbage() instead"));
        ObjectItem->ClearFlags(FlagsToClear);
    }
 
    inline bool AtomicallyClearInternalFlags(EInternalObjectFlags FlagsToClear) const
    {
        FUObjectItem* ObjectItem = GUObjectArray.IndexToObject(InternalIndex);
        checkf((ObjectItem->GetFlags() & (FlagsToClear & EInternalObjectFlags::Garbage)) == EInternalObjectFlags::None, TEXT("ClearInternalFlags should not clear Garbage flag. Use ClearGarbage() instead"));
        return ObjectItem->ThisThreadAtomicallyClearedFlag(FlagsToClear);
    }
 
 
    /*-------------------
            Names
    -------------------*/
 
    COREUOBJECT_API FString GetFullName( const UObject* StopOuter=NULL, EObjectFullNameFlags Flags = EObjectFullNameFlags::None ) const;
 
    COREUOBJECT_API void GetFullName( const UObject* StopOuter, FString& ResultString, EObjectFullNameFlags Flags = EObjectFullNameFlags::None ) const;
 
    COREUOBJECT_API void GetFullName(FStringBuilderBase& ResultString, const UObject* StopOuter = NULL, EObjectFullNameFlags Flags = EObjectFullNameFlags::None) const;
 
    COREUOBJECT_API FString GetPathName( const UObject* StopOuter=NULL ) const;
 
    COREUOBJECT_API void GetPathName(const UObject* StopOuter, FString& ResultString) const;
    COREUOBJECT_API void GetPathName(const UObject* StopOuter, FStringBuilderBase& ResultString) const;
 
    static inline bool IsGarbageEliminationEnabled()
    {
        return bGarbageEliminationEnabled;
    }
 
    UE_DEPRECATED(5.4, "Use IsGarbageEliminationEnabled()")
    static inline bool IsPendingKillEnabled()
    {
        return IsGarbageEliminationEnabled();
    }
 
    static inline void SetGarbageEliminationEnabled(bool bEnabled)
    {
        bGarbageEliminationEnabled = bEnabled;
    }
 
public:
    virtual bool CanBeClusterRoot() const
    {
        return false;
    }
 
    COREUOBJECT_API virtual bool CanBeInCluster() const;
 
    COREUOBJECT_API virtual void CreateCluster();
 
    virtual void OnClusterMarkedAsPendingKill() {}
 
    COREUOBJECT_API void AddToCluster(UObjectBaseUtility* ClusterRootOrObjectFromCluster, bool bAddAsMutableObject = false);
 
public:
    COREUOBJECT_API FString GetFullGroupName( bool bStartWithOuter ) const;
 
    UE_FORCEINLINE_HINT FString GetName() const
    {
        return GetFName().ToString();
    }
 
    UE_FORCEINLINE_HINT void GetName(FString &ResultString) const
    {
        GetFName().ToString(ResultString);
    }
    UE_FORCEINLINE_HINT void AppendName(FString& ResultString) const
    {
        GetFName().AppendString(ResultString);
    }
 
 
    /*-------------------
        Outer & Package
    -------------------*/
 
    COREUOBJECT_API bool IsPackageExternal() const;
 
    COREUOBJECT_API void DetachExternalPackage();
 
    COREUOBJECT_API void ReattachExternalPackage();
 
    COREUOBJECT_API UObject* GetOutermostObject() const;
 
    COREUOBJECT_API UPackage* GetPackage() const;
 
    UE_INTERNAL COREUOBJECT_API virtual UE::Core::FVersePath GetVersePath() const;
 
    COREUOBJECT_API UPackage* GetOutermost() const;
 
    COREUOBJECT_API bool MarkPackageDirty() const;
 
    COREUOBJECT_API bool IsTemplate(EObjectFlags TemplateTypes = RF_ArchetypeObject|RF_ClassDefaultObject) const;
 
    COREUOBJECT_API UObject* GetTypedOuter(UClass* Target) const;
 
    template<typename T>
    T* GetTypedOuter() const
    {
        return (T *)GetTypedOuter(T::StaticClass());
    }
 
    template<typename InterfaceClassType>
    InterfaceClassType* GetImplementingOuter() const
    {
        UClass* InterfaceClass = InterfaceClassType::UClassType::StaticClass();
        if(UObjectBaseUtility* ImplementingOuter = GetImplementingOuterObject(InterfaceClass))
        {
            return static_cast<InterfaceClassType*>(ImplementingOuter->GetInterfaceAddress(InterfaceClass));
        }
        return nullptr;
    }
 
    COREUOBJECT_API UObjectBaseUtility* GetImplementingOuterObject(const UClass* InInterfaceClass) const;
 
    COREUOBJECT_API bool IsIn( const UObject* SomeOuter ) const;
 
    COREUOBJECT_API bool IsIn(const UPackage* SomePackage) const;
 
    COREUOBJECT_API bool IsInOuter(const UObject* SomeOuter) const;
 
    COREUOBJECT_API bool IsInPackage(const UPackage* SomePackage) const;
 
    COREUOBJECT_API bool IsInA( const UClass* SomeBaseClass ) const;
 
    COREUOBJECT_API bool RootPackageHasAnyFlags( uint32 CheckFlagMask ) const;
 
 
    /*-------------------
            Class
    -------------------*/
 
private:
    template <typename ClassType>
    static UE_FORCEINLINE_HINT bool IsChildOfWorkaround(const ClassType* ObjClass, const ClassType* TestCls)
    {
        return ObjClass->IsChildOf(TestCls);
    }
 
public:
    template <typename OtherClassType>
    inline 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);
    }
 
    template<class T>
    bool IsA() const
    {
        return IsA(T::StaticClass());
    }
 
    COREUOBJECT_API const UClass* FindNearestCommonBaseClass( const UClass* TestClass ) const;
 
    COREUOBJECT_API void* GetInterfaceAddress( UClass* InterfaceClass );
 
    COREUOBJECT_API void* GetNativeInterfaceAddress(UClass* InterfaceClass);
 
    const void* GetNativeInterfaceAddress(UClass* InterfaceClass) const
    {
        return const_cast<UObjectBaseUtility*>(this)->GetNativeInterfaceAddress(InterfaceClass);
    }
 
    COREUOBJECT_API bool IsTemplateForSubobjects(EObjectFlags TemplateTypes = RF_ClassDefaultObject|RF_DefaultSubObject|RF_InheritableComponentTemplate) const;
    
    COREUOBJECT_API bool IsDefaultSubobject() const;
    
 
    /*--------------------------------------------------
            Linker, defined in UObjectLinker.cpp
    --------------------------------------------------*/
 
    COREUOBJECT_API class FLinkerLoad* GetLinker() const;
 
    COREUOBJECT_API int32 GetLinkerIndex() const;
 
    COREUOBJECT_API FPackageFileVersion GetLinkerUEVersion() const;
        
    UE_DEPRECATED(5.0, "Use GetLinkerUEVersion instead which returns the version as a FPackageFileVersion. See the @FPackageFileVersion documentation for further details")
    inline int32 GetLinkerUE4Version() const 
    { 
        // Existing code calling GetLinkerUE4Version will be testing against UE4 version numbers so 
        // we can just return the UE4 version number.
        // All new code that might actually need the UE5 version as well should be calling ::GetLinkerUEVersion
        return GetLinkerUEVersion().FileVersionUE4;
    }
 
    COREUOBJECT_API int32 GetLinkerLicenseeUEVersion() const;
 
    UE_DEPRECATED(5.0, "Use GetLinkerLicenseeUEVersion instead")
    inline int32 GetLinkerLicenseeUE4Version() const { return GetLinkerLicenseeUEVersion(); }
 
 
    COREUOBJECT_API int32 GetLinkerCustomVersion(FGuid CustomVersionKey) const;
 
    UE_FORCEINLINE_HINT bool operator<( const UObjectBaseUtility& Other ) const
    {
        return GetName() < Other.GetName();
    }
 
 
 
    /*******
     * Stats
     *******/
#if STATS || ENABLE_STATNAMEDEVENTS_UOBJECT
    inline void ResetStatID()
    {
        GUObjectArray.IndexToObject(InternalIndex)->StatID = TStatId();
#if ENABLE_STATNAMEDEVENTS_UOBJECT
        GUObjectArray.IndexToObject(InternalIndex)->StatIDStringStorage = nullptr;
#endif
    }
#endif
    inline TStatId GetStatID(bool bForDeferredUse = false) const
    {
        TStatId Result{};
        UE_AUTORTFM_OPEN
        {
#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();
                }
                Result = StatID;
            }
            else
            {
                Result = TStatId(); // not doing stats at the moment, or ever
            }
#elif ENABLE_STATNAMEDEVENTS_UOBJECT
            const TStatId& StatID = GUObjectArray.IndexToObject(InternalIndex)->StatID;
            if (!StatID.IsValidStat() && (bForDeferredUse || GCycleStatsShouldEmitNamedEvents))
            {
                CreateStatID();
            }
            Result = StatID;
#else
            Result = TStatId(); // not doing stats at the moment, or ever
#endif // STATS
        };
        return Result;
    }
 
private:
#if STATS || ENABLE_STATNAMEDEVENTS_UOBJECT
    void CreateStatID() const
    {
        GUObjectArray.IndexToObject(InternalIndex)->CreateStatID();
    }
#endif
 
        
    /*******
     * Config
     *******/
public:
    COREUOBJECT_API static void ReloadObjectsFromModifiedConfigSections(const class FConfigModificationTracker* ChangeTracker);
};
 
inline bool IsPossiblyAllocatedUObjectPointer(UObject* Ptr)
{
    auto CountByteValues = [](UPTRINT Val, UPTRINT ByteVal) -> int32
    {
        int32 Result = 0;
 
        // != changed to < because of false positive in MSVC's static analyzer: warning C6295: Ill-defined for-loop.  Loop executes infinitely.
        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;
}
 
inline FName GetFNameSafe(const UObjectBaseUtility* Object)
{
    if (Object == nullptr)
    {
        return NAME_None;
    }
    else
    {
        return Object->GetFName();
    }
}
 
inline FString GetNameSafe(const UObjectBaseUtility* Object)
{
    if (Object == nullptr)
    {
        return TEXT("None");
    }
    else
    {
        return Object->GetName();
    }
}
 
inline FString GetPathNameSafe(const UObjectBaseUtility* Object)
{
    if (Object == nullptr)
    {
        return TEXT("None");
    }
    else
    {
        return Object->GetPathName();
    }
}
 
inline FString GetFullNameSafe(const UObjectBaseUtility* Object)
{
    if (!Object || !Object->GetClass())
    {
        return TEXT("None");
    }
    else
    {
        return Object->GetFullName();
    }
}
 
COREUOBJECT_API UClass* GetParentNativeClass(UClass* Class);
 
COREUOBJECT_API UClass* GetTopMostNonNativeClass(UClass* Class, bool bAllowReturnNativeClass);
 
#if !defined(USE_LIGHTWEIGHT_UOBJECT_STATS_FOR_HITCH_DETECTION)
#define USE_LIGHTWEIGHT_UOBJECT_STATS_FOR_HITCH_DETECTION (1)
#endif
 
#if CPUPROFILERTRACE_ENABLED
COREUOBJECT_API FName GetClassTraceScope(const UObjectBaseUtility* Object);
#endif
 
#if STATS
 
class FScopeCycleCounterUObject : public FCycleCounter
{
public:
    inline FScopeCycleCounterUObject(const UObjectBaseUtility *Object)
    {
        UE_AUTORTFM_OPEN
        {
            if (Object)
            {
                bool bStarted = false;
                TStatId ObjectStatId = Object->GetStatID();
                if (FThreadStats::IsCollectingData(ObjectStatId))
                {
                    Start(ObjectStatId);
                    bStarted = true;
                }
 
#if CPUPROFILERTRACE_ENABLED
                if (!bStarted && UE_TRACE_CHANNELEXPR_IS_ENABLED(CpuChannel))
                {
                    StartObjectTrace(Object);
                }
#endif
            }
        };
 
        AutoRTFM::PushOnAbortHandler(this, [this](){ this->Stop(); });
    }
    inline FScopeCycleCounterUObject(const UObjectBaseUtility *Object, TStatId OtherStat)
    {
        UE_AUTORTFM_OPEN
        {
            if (Object)
            {
                bool bStarted = false;
                if (FThreadStats::IsCollectingData(OtherStat))
                {
                    TStatId ObjectStatId = Object->GetStatID();
                    if (!ObjectStatId.IsNone())
                    {
                        Start(ObjectStatId);
                        bStarted = true;
                    }
                }
 
#if CPUPROFILERTRACE_ENABLED
                if (!bStarted && UE_TRACE_CHANNELEXPR_IS_ENABLED(CpuChannel))
                {
                    StartObjectTrace(Object);
                }
#endif
            }
        };
 
        AutoRTFM::PushOnAbortHandler(this, [this](){ this->Stop(); });
    }
 
#if CPUPROFILERTRACE_ENABLED
    COREUOBJECT_API void StartObjectTrace(const UObjectBaseUtility* Object);
#endif
 
    inline ~FScopeCycleCounterUObject()
    {
        AutoRTFM::PopOnAbortHandler(this);
        UE_AUTORTFM_OPEN
        {
            Stop();
        };
    }
};
 
#define SCOPE_CYCLE_UOBJECT(Name, Object) \
    FScopeCycleCounterUObject ObjCycleCount_##Name(Object);
 
#elif UE_USE_LIGHTWEIGHT_STATS
 
class FScopeCycleCounterUObject
{
public:
    FScopeCycleCounter ScopeCycleCounter;
#if ENABLE_STATNAMEDEVENTS_UOBJECT && CPUPROFILERTRACE_ENABLED
    bool bPop;
#endif
 
    inline FScopeCycleCounterUObject(const UObjectBaseUtility *Object)
        : ScopeCycleCounter(Object ? Object->GetStatID().StatString : nullptr)
#if ENABLE_STATNAMEDEVENTS_UOBJECT && CPUPROFILERTRACE_ENABLED
        , bPop(false)
#endif
    {
#if ENABLE_STATNAMEDEVENTS_UOBJECT && CPUPROFILERTRACE_ENABLED
        UE_AUTORTFM_OPEN
        {
            if (GCycleStatsShouldEmitNamedEvents && UE_TRACE_CHANNELEXPR_IS_ENABLED(CpuChannel) && Object)
            {
                const TStatId ObjectStatId = Object->GetStatID();
                if (ObjectStatId.IsValidStat())
                {
                    bPop = true;
                    FCpuProfilerTrace::OutputBeginDynamicEvent(ObjectStatId.StatString);
                }
            }
        };
 
        if(bPop)
        {
            AutoRTFM::PushOnAbortHandler(this, [](){ FCpuProfilerTrace::OutputEndEvent(); });
        }
#endif
    }
 
    UE_FORCEINLINE_HINT FScopeCycleCounterUObject(const UObjectBaseUtility *Object, TStatId OtherStat)
        : FScopeCycleCounterUObject(Object)
    {
    }
 
    inline ~FScopeCycleCounterUObject()
    {
#if ENABLE_STATNAMEDEVENTS_UOBJECT && CPUPROFILERTRACE_ENABLED
        if (bPop)
        {
            AutoRTFM::PopOnAbortHandler(this);
 
            UE_AUTORTFM_OPEN
            {
                FCpuProfilerTrace::OutputEndEvent();
            };
        }
#endif
    }
};
 
#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 TSAN_ATOMIC(bool) GHitchDetected;
 
class FScopeCycleCounterUObject
{
    const UObject* StatObject;
public:
    UE_FORCEINLINE_HINT  FScopeCycleCounterUObject(const UObject* InStatObject, TStatId OtherStat = TStatId())
    {
        StatObject = GHitchDetected ? nullptr : InStatObject;
    }
 
    inline ~FScopeCycleCounterUObject()
    {
        if (GHitchDetected &&  StatObject)
        {
            UE_AUTORTFM_OPEN
            {
                ReportHitch();
            };
        }
    }
 
    COREUOBJECT_API void ReportHitch();
};
 
#define SCOPE_CYCLE_UOBJECT(Name, Object) \
    FScopeCycleCounterUObject ObjCycleCount_##Name(Object);
#else
class FScopeCycleCounterUObject
{
public:
    UE_FORCEINLINE_HINT FScopeCycleCounterUObject(const UObjectBaseUtility *Object)
    {
    }
    UE_FORCEINLINE_HINT 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