UObjectGlobals.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UObjectGlobals.h: Unreal object system globals.
=============================================================================*/
 
#pragma once
 
#include "Concepts/SameAs.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/ContainersFwd.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/SparseArray.h"
#include "Containers/StringFwd.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Internationalization/Text.h"
#include "Logging/LogMacros.h"
#include "Logging/LogVerbosity.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/OutputDeviceRedirector.h"
#include "Misc/PackagePath.h"
#include "Serialization/ArchiveUObject.h"
#include "Serialization/MemoryLayout.h"
#include "Stats/Stats.h"
#include "Templates/Function.h"
#include "Templates/IsArrayOrRefOfTypeByPredicate.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/IsTObjectPtr.h"
#include "Traits/IsCharEncodingCompatibleWith.h"
#include "UObject/FindObjectFlags.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectHandle.h"
#include "UObject/PrimaryAssetId.h"
#include "UObject/Script.h"
#include "UObject/TopLevelAssetPath.h"
#include "UObject/RemoteObjectTypes.h"
#include "UObject/UnrealNames.h"
#include "VerseTypesFwd.h"
 
class FArchive;
class FCbWriter;
class FLinkerInstancingContext;
class FObjectPreSaveContext;
class FOutputDevice;
class FPackagePath;
class FProperty;
class ITargetPlatform;
class UClass;
class UEnum;
class UFunction;
class UObject;
class UObjectBase;
class UPackage;
class UPackageMap;
class UScriptStruct;
class UWorld;
struct FCustomPropertyListNode;
struct FGuid;
struct FObjectInstancingGraph;
struct FObjectPostCDOCompiledContext;
struct FObjectPtr;
struct FPrimaryAssetId;
struct FStaticConstructObjectParameters;
struct FUObjectSerializeContext;
struct FWorldContext;
template <typename T>
struct TObjectPtr;
 
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogUObjectGlobals, Log, All);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("ConstructObject"),STAT_ConstructObject,STATGROUP_Object, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("AllocateObject"),STAT_AllocateObject,STATGROUP_ObjectVerbose, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("PostConstructInitializeProperties"),STAT_PostConstructInitializeProperties,STATGROUP_ObjectVerbose, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("LoadConfig"),STAT_LoadConfig,STATGROUP_Object, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("LoadObject"),STAT_LoadObject,STATGROUP_Object, );
DECLARE_CYCLE_STAT_WITH_FLAGS_EXTERN(TEXT("InitProperties"),STAT_InitProperties,STATGROUP_Object, EStatFlags::Verbose, );
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("NameTable Entries"),STAT_NameTableEntries,STATGROUP_Object, );
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("NameTable ANSI Entries"),STAT_NameTableAnsiEntries,STATGROUP_Object, );
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("NameTable Wide Entries"),STAT_NameTableWideEntries,STATGROUP_Object, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("NameTable Memory Size"),STAT_NameTableMemorySize,STATGROUP_Object, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("~UObject"),STAT_DestroyObject,STATGROUP_Object, );
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("FindObject"),STAT_FindObject,STATGROUP_ObjectVerbose, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("FindObjectFast"),STAT_FindObjectFast,STATGROUP_ObjectVerbose, );
 
#define INVALID_OBJECT  (UObject*)-1
#define PERF_TRACK_DETAILED_ASYNC_STATS (0)
 
#ifndef UE_GC_RUN_WEAKPTR_BARRIERS
#define UE_GC_RUN_WEAKPTR_BARRIERS 0
#endif
 
#if UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR
#define UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED() UE_DEPRECATED(5.3, "WARNING: Your program will randomly crash if this function is called when incremental gc is enabled. Pass TObjectPtr<...> instead of UObject* to AddReferencedObject(s) API's.")
#else
#define UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED(...)
#endif
 
// Private system wide variables.
 
//UE_DEPRECATED(5.0, "Use the IsSavingPackage() function instead.")
extern COREUOBJECT_API bool                 GIsSavingPackage;
extern COREUOBJECT_API int32                GAllowUnversionedContentInEditor;
extern COREUOBJECT_API int32                GAllowCookedDataInEditorBuilds;
 
namespace EDuplicateMode
{
    enum Type
    {
        Normal,
        World,
        PIE
    };
};
 
/*-----------------------------------------------------------------------------
    FObjectDuplicationParameters.
-----------------------------------------------------------------------------*/
 
struct FObjectDuplicationParameters
{
    UObject*        SourceObject;
 
    UObject*        DestOuter;
 
    FName           DestName;
 
    EObjectFlags    FlagMask;
 
    EInternalObjectFlags InternalFlagMask;
 
    EObjectFlags    ApplyFlags;
 
    EInternalObjectFlags    ApplyInternalFlags;
 
    uint32          PortFlags;
 
    EDuplicateMode::Type DuplicateMode;
 
    bool bAssignExternalPackages = true;
 
    bool bSkipPostLoad = false;
    
    UClass*         DestClass;
 
    TMap<UObject*,UObject*> DuplicationSeed;
 
    TMap<UObject*,UObject*>* CreatedObjects;
 
    COREUOBJECT_API FObjectDuplicationParameters( UObject* InSourceObject, UObject* InDestOuter );
};
 
// @note: should we start putting the code in the UE namespace?
namespace UE
{
    COREUOBJECT_API bool IsSavingPackage(UObject* InOuter = nullptr);
 
} // namespace UE
 
namespace UE::RemoteObject::Serialization
{
    class FRemoteObjectConstructionOverrides;
} // namespace UE::RemoteObject::Serialization
 
COREUOBJECT_API TArray<const TCHAR*> ParsePropertyFlags(EPropertyFlags Flags);
 
COREUOBJECT_API UPackage* GetTransientPackage();
COREUOBJECT_API UObject* GetTransientPackageAsObject();
 
COREUOBJECT_API UObject* GetTransientOuterForRename(UClass* ForClass);
 
COREUOBJECT_API const FString* GetIniFilenameFromObjectsReference(const FString& ObjectsReferenceString);
 
COREUOBJECT_API FString ResolveIniObjectsReference(const FString& ObjectReference, const FString* IniFilename = nullptr, bool bThrow = false);
 
COREUOBJECT_API bool ResolveName(UObject*& Outer, FString& ObjectsReferenceString, bool Create, bool Throw, uint32 LoadFlags = LOAD_None, const FLinkerInstancingContext* InstancingContext = nullptr);
 
COREUOBJECT_API bool SafeLoadError( UObject* Outer, uint32 LoadFlags, const TCHAR* ErrorMessage);
 
COREUOBJECT_API int32 UpdateSuffixForNextNewObject(UObject* Parent, const UClass* Class, TFunctionRef<void(int32&)> IndexMutator);
 
COREUOBJECT_API UObject* StaticFindObjectFast(UClass* Class, 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("StaticFindObjectFast")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObjectFast(UClass* Class, UObject* InOuter, FName InName, ExactClassType bExactClass, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None)
{
    return StaticFindObjectFast(Class, InOuter, InName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExclusiveFlags, ExclusiveInternalFlags);
}
 
COREUOBJECT_API UObject* StaticFindObjectFastSafe(UClass* Class, 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("StaticFindObjectFastSafe")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObjectFastSafe(UClass* Class, UObject* InOuter, FName InName, ExactClassType bExactClass, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None)
{
    return StaticFindObjectFastSafe(Class, InOuter, InName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExclusiveFlags, ExclusiveInternalFlags);
}
 
COREUOBJECT_API UObject* StaticFindObject( UClass* Class, UObject* InOuter, FStringView Name, EFindObjectFlags Flags = EFindObjectFlags::None );
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindObject")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObject( UClass* Class, UObject* InOuter, FStringView Name, ExactClassType bExactClass )
{
    return StaticFindObject(Class, InOuter, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
COREUOBJECT_API UObject* StaticFindObject(UClass* Class, FTopLevelAssetPath ObjectPath, EFindObjectFlags Flags = EFindObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindObject")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObject(UClass* Class, FTopLevelAssetPath ObjectPath, ExactClassType bExactClass)
{
    return StaticFindObject(Class, ObjectPath, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
COREUOBJECT_API UObject* StaticFindObjectChecked( UClass* Class, UObject* InOuter, FStringView Name, EFindObjectFlags Flags = EFindObjectFlags::None );
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindObjectChecked")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObjectChecked( UClass* Class, UObject* InOuter, FStringView Name, ExactClassType bExactClass)
{
    return StaticFindObjectChecked(Class, InOuter, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
COREUOBJECT_API UObject* StaticFindObjectSafe( UClass* Class, UObject* InOuter, FStringView Name, EFindObjectFlags Flags = EFindObjectFlags::None );
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindObjectSafe")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObjectSafe( UClass* Class, UObject* InOuter, FStringView Name, ExactClassType bExactClass )
{
    return StaticFindObjectSafe(Class, InOuter, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
COREUOBJECT_API UObject* StaticFindObjectSafe(UClass* Class, FTopLevelAssetPath ObjectPath, EFindObjectFlags Flags = EFindObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindObjectSafe")
UE_NODEBUG UE_FORCEINLINE_HINT UObject* StaticFindObjectSafe(UClass* Class, FTopLevelAssetPath ObjectPath, ExactClassType bExactClass)
{
    return StaticFindObjectSafe(Class, ObjectPath, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
COREUOBJECT_API bool StaticFindAllObjectsFast(TArray<UObject*>& OutFoundObjects, UClass* ObjectClass, FName ObjectName, EFindObjectFlags Flags = EFindObjectFlags::None, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindAllObjectsFast")
UE_NODEBUG UE_FORCEINLINE_HINT bool StaticFindAllObjectsFast(TArray<UObject*>& OutFoundObjects, UClass* ObjectClass, FName ObjectName, ExactClassType bExactClass, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None)
{
    return StaticFindAllObjectsFast(OutFoundObjects, ObjectClass, ObjectName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExclusiveFlags, ExclusiveInternalFlags);
}
 
COREUOBJECT_API bool StaticFindAllObjectsFastSafe(TArray<UObject*>& OutFoundObjects, UClass* ObjectClass, FName ObjectName, EFindObjectFlags Flags = EFindObjectFlags::None, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindAllObjectsFastSafe")
UE_NODEBUG UE_FORCEINLINE_HINT bool StaticFindAllObjectsFastSafe(TArray<UObject*>& OutFoundObjects, UClass* ObjectClass, FName ObjectName, ExactClassType bExactClass, EObjectFlags ExclusiveFlags = RF_NoFlags, EInternalObjectFlags ExclusiveInternalFlags = EInternalObjectFlags::None)
{
    return StaticFindAllObjectsFastSafe(OutFoundObjects, ObjectClass, ObjectName, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExclusiveFlags, ExclusiveInternalFlags);
}
 
COREUOBJECT_API bool StaticFindAllObjects(TArray<UObject*>& OutFoundObjects, UClass* Class, const TCHAR* Name, EFindObjectFlags Flags = EFindObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindAllObjects")
UE_NODEBUG UE_FORCEINLINE_HINT bool StaticFindAllObjects(TArray<UObject*>& OutFoundObjects, UClass* Class, const TCHAR* Name, ExactClassType bExactClass)
{
    return StaticFindAllObjects(OutFoundObjects, Class, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
COREUOBJECT_API bool StaticFindAllObjectsSafe(TArray<UObject*>& OutFoundObjects, UClass* Class, const TCHAR* Name, EFindObjectFlags Flags = EFindObjectFlags::None);
template <UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("StaticFindAllObjectsSafe")
UE_NODEBUG UE_FORCEINLINE_HINT bool StaticFindAllObjectsSafe(TArray<UObject*>& OutFoundObjects, UClass* Class, const TCHAR* Name, ExactClassType bExactClass)
{
    return StaticFindAllObjectsSafe(OutFoundObjects, Class, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
 
enum class EFindFirstObjectOptions
{
    None = 0, // Unused / defaults to Quiet
    ExactClass = 1 << 1, // Whether to require an exact match with the passed in class
    NativeFirst = 1 << 2, // If multiple results are found, prioritize native classes or native class instances
    EnsureIfAmbiguous = 1 << 3 // Ensure if multiple results are found
};
ENUM_CLASS_FLAGS(EFindFirstObjectOptions);
 
COREUOBJECT_API UObject* StaticFindFirstObject(UClass* Class, FStringView Name, EFindFirstObjectOptions Options = EFindFirstObjectOptions::None, ELogVerbosity::Type AmbiguousMessageVerbosity = ELogVerbosity::NoLogging, const TCHAR* InCurrentOperation = nullptr);
 
COREUOBJECT_API UObject* StaticFindFirstObjectSafe(UClass* Class, FStringView Name, EFindFirstObjectOptions Options = EFindFirstObjectOptions::None, ELogVerbosity::Type AmbiguousMessageVerbosity = ELogVerbosity::NoLogging, const TCHAR* InCurrentOperation = nullptr);
 
enum class EParseObjectLoadingPolicy : uint8
{
    Find,
    FindOrLoad,
};
 
COREUOBJECT_API bool ParseObject( const TCHAR* Stream, const TCHAR* Match, UClass* Class, UObject*& DestRes, UObject* InParent, EParseObjectLoadingPolicy LoadingPolicy, bool* bInvalidObject=nullptr );
inline bool ParseObject( const TCHAR* Stream, const TCHAR* Match, UClass* Class, UObject*& DestRes, UObject* InParent, bool* bInvalidObject=nullptr )
{
    return ParseObject( Stream, Match, Class, DestRes, InParent, EParseObjectLoadingPolicy::Find, bInvalidObject );
}
 
COREUOBJECT_API UObject* StaticLoadObject( UClass* Class, UObject* InOuter, FStringView Name, FStringView Filename = {}, uint32 LoadFlags = LOAD_None, UPackageMap* Sandbox = nullptr, bool bAllowObjectReconciliation = true, const FLinkerInstancingContext* InstancingContext = nullptr);
 
COREUOBJECT_API UClass* StaticLoadClass(UClass* BaseClass, UObject* InOuter, FStringView Name, FStringView Filename = {}, uint32 LoadFlags = LOAD_None, UPackageMap* Sandbox = nullptr);
 
COREUOBJECT_API UObject* StaticLoadAsset(UClass* Class, FTopLevelAssetPath InPath, uint32 LoadFlags = LOAD_None, const FLinkerInstancingContext* InstancingContext = nullptr);
 
COREUOBJECT_API UObject* StaticConstructObject_Internal(const FStaticConstructObjectParameters& Params);
 
COREUOBJECT_API UObject* StaticDuplicateObject(UObject const* SourceObject, UObject* DestOuter, const FName DestName = NAME_None, EObjectFlags FlagMask = RF_AllFlags, UClass* DestClass = nullptr, EDuplicateMode::Type DuplicateMode = EDuplicateMode::Normal, EInternalObjectFlags InternalFlagsMask = EInternalObjectFlags_AllFlags);
 
COREUOBJECT_API FObjectDuplicationParameters InitStaticDuplicateObjectParams(UObject const* SourceObject, UObject* DestOuter, const FName DestName = NAME_None, EObjectFlags FlagMask = RF_AllFlags, UClass* DestClass = nullptr, EDuplicateMode::Type DuplicateMode = EDuplicateMode::Normal, EInternalObjectFlags InternalFlagsMask = EInternalObjectFlags_AllFlags);
 
COREUOBJECT_API UObject* StaticDuplicateObjectEx( FObjectDuplicationParameters& Parameters );
 
COREUOBJECT_API bool StaticExec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar=*GLog );
 
COREUOBJECT_API void StaticTick( float DeltaTime, bool bUseFullTimeLimit = true, float AsyncLoadingTime = 0.005f );
 
COREUOBJECT_API UPackage* LoadPackage( UPackage* InOuter, const TCHAR* InLongPackageName, uint32 LoadFlags, FArchive* InReaderOverride = nullptr, const FLinkerInstancingContext* InstancingContext = nullptr);
 
COREUOBJECT_API UPackage* LoadPackage(UPackage* InOuter, const FPackagePath& InPackagePath, uint32 LoadFlags, FArchive* InReaderOverride = nullptr, const FLinkerInstancingContext* InstancingContext = nullptr, const FPackagePath* DiffPackagePath = nullptr);
 
namespace EAsyncLoadingResult
{
    enum Type : uint8
    {
        Failed,
        FailedMissing,
        FailedLinker,
        FailedNotInstalled,
        Succeeded,
        Canceled
    };
}
 
enum class EAsyncLoadingProgress : uint32
{
    Failed,
    Started,
    Read,
    Serialized,
    FullyLoaded
};
 
typedef int32 TAsyncLoadPriority;
 
DECLARE_DELEGATE_ThreeParams(FLoadPackageAsyncDelegate, const FName& /*PackageName*/, UPackage* /*LoadedPackage*/, EAsyncLoadingResult::Type /*Result*/)
 
 
struct FLoadPackageAsyncProgressParams
{
    /* Name of the package. */
    const FName PackageName { NAME_None };
    /* Pointer to UPackage being loaded, can be nullptr depending on async loading progress. */
    const UPackage* LoadedPackage { nullptr };
    /* Progress of async loading. */
    const EAsyncLoadingProgress ProgressType { EAsyncLoadingProgress::Failed };
};
 
class FLoadPackageAsyncProgressDelegate
{
public:
    using DelegateType = TTSDelegate<void(FLoadPackageAsyncProgressParams& Params)>;
 
    FLoadPackageAsyncProgressDelegate(DelegateType&& InDelegate, uint32 InMask = MAX_uint32)
        : Delegate(InDelegate)
        , Mask(InMask)
    {}
 
    constexpr static inline uint32 BuildMask(EAsyncLoadingProgress Progress)
    {
        return 1 << (uint32)Progress;
    }
 
    constexpr static inline uint32 BuildMask(auto... Types)
    {
        return (0 | ... | BuildMask(Types));
    }
 
    void Invoke(FLoadPackageAsyncProgressParams& Params)
    {
        if (Mask & BuildMask(Params.ProgressType))
        {
            Delegate.ExecuteIfBound(Params);
        }
    }
 
private:
    TTSDelegate<void(FLoadPackageAsyncProgressParams& Params)> Delegate;
    const uint32 Mask { MAX_uint32 };
};
 
struct FLoadPackageAsyncOptionalParams
{
    FName CustomPackageName { NAME_None };
    TUniquePtr<FLoadPackageAsyncDelegate> CompletionDelegate;
    TSharedPtr<FLoadPackageAsyncProgressDelegate> ProgressDelegate;
    EPackageFlags PackageFlags { PKG_None };
    int32 PIEInstanceID { INDEX_NONE };
    int32 PackagePriority { 0 };
    const FLinkerInstancingContext* InstancingContext { nullptr };
    uint32 LoadFlags { LOAD_None };
};
 
COREUOBJECT_API int32 LoadPackageAsync(const FPackagePath& InPackagePath, FLoadPackageAsyncOptionalParams InOptionalParams);
 
COREUOBJECT_API int32 LoadPackageAsync(const FPackagePath& InPackagePath, FName InPackageNameToCreate = NAME_None, FLoadPackageAsyncDelegate InCompletionDelegate = FLoadPackageAsyncDelegate(), EPackageFlags InPackageFlags = PKG_None, int32 InPIEInstanceID = INDEX_NONE, TAsyncLoadPriority InPackagePriority = 0, const FLinkerInstancingContext* InstancingContext = nullptr, uint32 LoadFlags = LOAD_None);
 
COREUOBJECT_API int32 LoadPackageAsync(const FString& InName, const FGuid* InGuid = nullptr);
 
COREUOBJECT_API int32 LoadPackageAsync(const FString& InName, FLoadPackageAsyncDelegate InCompletionDelegate, TAsyncLoadPriority InPackagePriority = 0, EPackageFlags InPackageFlags = PKG_None, int32 InPIEInstanceID = INDEX_NONE);
 
COREUOBJECT_API int32 LoadPackageAsync(const FString& InName, FLoadPackageAsyncOptionalParams InOptionalParams);
 
 
DECLARE_DELEGATE_ThreeParams(FLoadAssetAsyncDelegate, const FTopLevelAssetPath& /*AssetPath*/, UObject* /*LoadedObject*/, EAsyncLoadingResult::Type /*Result*/)
 
 
struct FLoadAssetAsyncOptionalParams
{
    TSharedPtr<FLoadPackageAsyncProgressDelegate> ProgressDelegate;
    int32 PackagePriority { 0 };
    const FLinkerInstancingContext* InstancingContext { nullptr };
    uint32 LoadFlags { LOAD_None };
};
 
COREUOBJECT_API int32 LoadAssetAsync(FTopLevelAssetPath InAssetPath, FLoadAssetAsyncDelegate InCompletionDelegate, FLoadAssetAsyncOptionalParams InOptionalParams = FLoadAssetAsyncOptionalParams());
 
 
COREUOBJECT_API void CancelAsyncLoading();
 
COREUOBJECT_API bool IsEventDrivenLoaderEnabled();
 
COREUOBJECT_API float GetAsyncLoadPercentage( const FName& PackageName );
 
COREUOBJECT_API void CollectGarbage(EObjectFlags KeepFlags, bool bPerformFullPurge = true);
 
COREUOBJECT_API bool TryCollectGarbage(EObjectFlags KeepFlags, bool bPerformFullPurge = true);
 
COREUOBJECT_API bool UnhashUnreachableObjects(bool bUseTimeLimit, double TimeLimit = 0.0);
 
COREUOBJECT_API bool IsIncrementalUnhashPending();
 
COREUOBJECT_API bool IsIncrementalPurgePending();
 
COREUOBJECT_API void GatherUnreachableObjects(bool bForceSingleThreaded);
 
COREUOBJECT_API bool IsIncrementalReachabilityAnalysisPending();
 
COREUOBJECT_API void PerformIncrementalReachabilityAnalysis(double TimeLimit);
 
COREUOBJECT_API void FinalizeIncrementalReachabilityAnalysis();
 
COREUOBJECT_API void IncrementalPurgeGarbage( bool bUseTimeLimit, double TimeLimit = 0.002 );
 
 
enum class EUniqueObjectNameOptions
{
    None = 0,
    GloballyUnique      = 1 << 1,   // Whether to make the object name unique globally (across all objects that currently exist in the current session)
    UniversallyUnique   = 1 << 2    // Whether to make the object name unique universally (across all objects that currently exist in all sessions)
};
ENUM_CLASS_FLAGS(EUniqueObjectNameOptions);
 
 
#if WITH_EDITOR
COREUOBJECT_API void ReleaseUniquelyNamedObject(UObject* Object);
#endif
 
COREUOBJECT_API FName MakeUniqueObjectName( UObject* Outer, const UClass* Class, FName BaseName = NAME_None, EUniqueObjectNameOptions Options = EUniqueObjectNameOptions::None);
 
struct FUniversallyUniqueObjectNameGenerator
{
    COREUOBJECT_API FUniversallyUniqueObjectNameGenerator(const FGuid& Seed);
    COREUOBJECT_API uint32 GetNewValue() const;
 
    TCHAR SessionIdBase36[14];
    mutable std::atomic<uint32> Seed;
};
 
COREUOBJECT_API FName MakeUniversallyUniqueObjectName(UObject* Outer, FName InBaseName = NAME_None, FUniversallyUniqueObjectNameGenerator const* Generator = nullptr);
 
COREUOBJECT_API bool HasUniversallyUniqueObjectNameIdentifier(FName Name);
 
COREUOBJECT_API FName MakeObjectNameFromDisplayLabel(const FString& DisplayLabel, const FName CurrentObjectName);
 
COREUOBJECT_API bool IsReferenced( UObject*& Res, EObjectFlags KeepFlags, EInternalObjectFlags InternalKeepFlags, bool bCheckSubObjects = false, FReferencerInformationList* FoundReferences = nullptr );
 
COREUOBJECT_API void FlushAsyncLoading(int32 PackageID = INDEX_NONE);
 
COREUOBJECT_API void FlushAsyncLoading(TConstArrayView<int32> RequestIds);
 
COREUOBJECT_API int32 GetNumAsyncPackages();
 
COREUOBJECT_API bool IsLoading();
 
COREUOBJECT_API void SetAsyncLoadingAllowed(bool bAllowAsyncLoading);
 
namespace EAsyncPackageState
{
    enum Type
    {
        TimeOut = 0,
        PendingImports,
        Complete,
    };
}
 
COREUOBJECT_API EAsyncPackageState::Type ProcessAsyncLoading( bool bUseTimeLimit, bool bUseFullTimeLimit, double TimeLimit);
 
COREUOBJECT_API EAsyncPackageState::Type ProcessAsyncLoadingUntilComplete(TFunctionRef<bool()> CompletionPredicate, double TimeLimit);
 
COREUOBJECT_API void BeginLoad(FUObjectSerializeContext* LoadContext, const TCHAR* DebugContext = nullptr);
COREUOBJECT_API void EndLoad(FUObjectSerializeContext* LoadContext);
 
COREUOBJECT_API UPackage* FindPackage(UObject* InOuter, const TCHAR* PackageName);
 
#if WITH_EDITOR
COREUOBJECT_API void SetMountPointDefaultPackageFlags(const TMap<FString, EPackageFlags>& InMountPointToDefaultPackageFlags);
 
COREUOBJECT_API void RemoveMountPointDefaultPackageFlags(const TArrayView<FString> InMountPoints);
#endif
 
COREUOBJECT_API UPackage* CreatePackage(const TCHAR* PackageName);
 
void GlobalSetProperty( const TCHAR* Value, UClass* Class, FProperty* Property, bool bNotifyObjectOfChange );
 
COREUOBJECT_API bool SaveToTransactionBuffer(UObject* Object, bool bMarkDirty);
 
COREUOBJECT_API void SnapshotTransactionBuffer(UObject* Object);
COREUOBJECT_API void SnapshotTransactionBuffer(UObject* Object, TArrayView<const FProperty*> Properties);
 
 
struct FScopedAllowAbstractClassAllocation : public FNoncopyable
{
    COREUOBJECT_API FScopedAllowAbstractClassAllocation();
    COREUOBJECT_API ~FScopedAllowAbstractClassAllocation();
    static bool IsDisallowedAbstractClass(const UClass* InClass, EObjectFlags InFlags);
 
private:
    static int32 AllowAbstractCount;
};
 
bool StaticAllocateObjectErrorTests( const UClass* Class, UObject* InOuter, FName Name, EObjectFlags SetFlags);
 
COREUOBJECT_API UObject* StaticAllocateObject(const UClass* Class, UObject* InOuter, FName Name, EObjectFlags SetFlags, EInternalObjectFlags InternalSetFlags = EInternalObjectFlags::None, bool bCanReuseSubobjects = false, bool* bOutReusedSubobject = nullptr, UPackage* ExternalPackage = nullptr, int32 SerialNumber = 0, FRemoteObjectId RemoteId = FRemoteObjectId(), class FGCReconstructionGuard* GCGuard = nullptr);
 
enum class EObjectInitializerOptions
{
    None                            = 0,
    CopyTransientsFromClassDefaults = 1 << 0, // copy transient from the class defaults instead of the pass in archetype ptr
    InitializeProperties            = 1 << 1, // initialize property values with the archetype values
};
ENUM_CLASS_FLAGS(EObjectInitializerOptions)
 
class FGCObject;
 
class FObjectInitializer
{
public:
    COREUOBJECT_API FObjectInitializer();
 
    COREUOBJECT_API FObjectInitializer(UObject* InObj, UObject* InObjectArchetype, EObjectInitializerOptions InOptions, struct FObjectInstancingGraph* InInstanceGraph = nullptr);
 
    COREUOBJECT_API FObjectInitializer(UObject* InObj, const FStaticConstructObjectParameters& StaticConstructParams);
 
    UE_DEPRECATED(5.7, "FObjectInitializer constructor that takes remote object overrides is deprecated. Use FRemoteObjectConstructionOverridesScope instead.")
    FObjectInitializer(UObject* InObj, const FStaticConstructObjectParameters& StaticConstructParams, UE::RemoteObject::Serialization::FRemoteObjectConstructionOverrides* RemoteObjectOverides)
        : FObjectInitializer(InObj, StaticConstructParams)
    {
    }
 
private:
    COREUOBJECT_API void Construct_Internal();
 
public:
    COREUOBJECT_API ~FObjectInitializer();
 
    UE_FORCEINLINE_HINT UObject* GetArchetype() const
    {
        return ObjectArchetype;
    }
 
    UE_FORCEINLINE_HINT UObject* GetObj() const
    {
        return Obj;
    }
 
    UE_FORCEINLINE_HINT struct FObjectInstancingGraph* GetInstancingGraph()
    {
        return InstanceGraph;
    }
 
    UE_FORCEINLINE_HINT void AddPropertyPostInitCallback(TFunction<void()>&& Callback)
    {
        PropertyPostInitCallbacks.Add(MoveTemp(Callback));
    }
 
    COREUOBJECT_API UClass* GetClass() const;
 
    template<class TReturnType>
    TReturnType* CreateDefaultSubobject(UObject* Outer, FName SubobjectName, bool bTransient = false) const
    {
        UClass* ReturnType = TReturnType::StaticClass();
        return static_cast<TReturnType*>(CreateDefaultSubobject(Outer, SubobjectName, ReturnType, ReturnType, /*bIsRequired =*/ true, bTransient));
    }
 
    template<class TReturnType>
    TReturnType* CreateOptionalDefaultSubobject(UObject* Outer, FName SubobjectName, bool bTransient = false) const
    {
        UClass* ReturnType = TReturnType::StaticClass();
        return static_cast<TReturnType*>(CreateDefaultSubobject(Outer, SubobjectName, ReturnType, ReturnType, /*bIsRequired =*/ false, bTransient));
    }
 
    template<class TReturnType, class TClassToConstructByDefault> 
    TReturnType* CreateDefaultSubobject(UObject* Outer, FName SubobjectName, bool bTransient = false) const 
    { 
        return static_cast<TReturnType*>(CreateDefaultSubobject(Outer, SubobjectName, TReturnType::StaticClass(), TClassToConstructByDefault::StaticClass(), /*bIsRequired =*/ true, bTransient));
    }
 
    template<class TReturnType>
    TReturnType* CreateEditorOnlyDefaultSubobject(UObject* Outer, FName SubobjectName, bool bTransient = false) const
    {
        const UClass* ReturnType = TReturnType::StaticClass();
        return static_cast<TReturnType*>(CreateEditorOnlyDefaultSubobject(Outer, SubobjectName, ReturnType, bTransient));
    }
 
    COREUOBJECT_API UObject* CreateEditorOnlyDefaultSubobject(UObject* Outer, FName SubobjectName, const UClass* ReturnType, bool bTransient = false) const;
 
    COREUOBJECT_API UObject* CreateDefaultSubobject(UObject* Outer, FName SubobjectFName, const UClass* ReturnType, const UClass* ClassToCreateByDefault, bool bIsRequired = true, bool bIsTransient = false) const;
 
    const FObjectInitializer& SetDefaultSubobjectClass(FName SubobjectName, const UClass* Class) const
    {
        AssertIfSubobjectSetupIsNotAllowed(SubobjectName);
        SubobjectOverrides.Add(SubobjectName, Class);
        return *this;
    }
 
    template<class T>
    const FObjectInitializer& SetDefaultSubobjectClass(FName SubobjectName) const
    {
        return SetDefaultSubobjectClass(SubobjectName, T::StaticClass());
    }
 
    const FObjectInitializer& DoNotCreateDefaultSubobject(FName SubobjectName) const
    {
        AssertIfSubobjectSetupIsNotAllowed(SubobjectName);
        SubobjectOverrides.Add(SubobjectName, nullptr);
        return *this;
    }
 
    const FObjectInitializer& SetNestedDefaultSubobjectClass(FStringView SubobjectName, const UClass* Class) const
    {
        AssertIfSubobjectSetupIsNotAllowed(SubobjectName);
        SubobjectOverrides.Add(SubobjectName, Class);
        return *this;
    }
 
    const FObjectInitializer& SetNestedDefaultSubobjectClass(TArrayView<const FName> SubobjectNames, const UClass* Class) const
    {
        AssertIfSubobjectSetupIsNotAllowed(SubobjectNames);
        SubobjectOverrides.Add(SubobjectNames, Class);
        return *this;
    }
 
    template<class T>
    const FObjectInitializer& SetNestedDefaultSubobjectClass(FStringView SubobjectName) const
    {
        return SetNestedDefaultSubobjectClass(SubobjectName, T::StaticClass());
    }
 
    template<class T>
    const FObjectInitializer& SetNestedDefaultSubobjectClass(TArrayView<const FName> SubobjectNames) const
    {
        return SetNestedDefaultSubobjectClass(SubobjectNames, T::StaticClass());
    }
 
    const FObjectInitializer& DoNotCreateNestedDefaultSubobject(FStringView SubobjectName) const
    {
        AssertIfSubobjectSetupIsNotAllowed(SubobjectName);
        SubobjectOverrides.Add(SubobjectName, nullptr);
        return *this;
    }
 
    const FObjectInitializer& DoNotCreateNestedDefaultSubobject(TArrayView<const FName> SubobjectNames) const
    {
        AssertIfSubobjectSetupIsNotAllowed(SubobjectNames);
        SubobjectOverrides.Add(SubobjectNames, nullptr);
        return *this;
    }
 
    static COREUOBJECT_API void AssertIfInConstructor(UObject* Outer, const TCHAR* ErrorMessage);
 
    UE_FORCEINLINE_HINT void FinalizeSubobjectClassInitialization()
    {
        bSubobjectClassInitializationAllowed = false;
    }
 
    static COREUOBJECT_API FObjectInitializer& Get();
 
private:
 
    friend class UObject; 
    friend class FScriptIntegrationObjectHelper;
 
    template<class T>
    friend void InternalConstructor(const class FObjectInitializer& X);
 
    static COREUOBJECT_API void InitProperties(UObject* Obj, UClass* DefaultsClass, UObject* DefaultData, bool bCopyTransientsFromClassDefaults);
 
    COREUOBJECT_API bool IsInstancingAllowed() const;
 
    COREUOBJECT_API bool InitSubobjectProperties(bool bAllowInstancing) const;
 
    COREUOBJECT_API void InstanceSubobjects(UClass* Class, bool bNeedInstancing, bool bNeedSubobjectInstancing) const;
 
    static COREUOBJECT_API bool InitNonNativeProperty(FProperty* Property, UObject* Data);
    
    COREUOBJECT_API void PostConstructInit();
 
private:
 
    struct FOverrides
    {
        COREUOBJECT_API void Add(FName InComponentName, const UClass* InComponentClass, const TArrayView<const FName>* FullPath = nullptr);
 
        COREUOBJECT_API void Add(FStringView InComponentPath, const UClass* InComponentClass);
 
        COREUOBJECT_API void Add(TArrayView<const FName> InComponentPath, const UClass* InComponentClass, const TArrayView<const FName>* FullPath = nullptr);
 
        struct FOverrideDetails
        {
            const UClass* Class = nullptr;
            FOverrides* SubOverrides = nullptr;
        };
 
        FOverrideDetails Get(FName InComponentName, const UClass* ReturnType, const UClass* ClassToConstructByDefault, bool bOptional) const;
 
    private:
        static bool IsLegalOverride(const UClass* DerivedComponentClass, const UClass* BaseComponentClass);
 
        int32 Find(FName InComponentName) const
        {
            for (int32 Index = 0 ; Index < Overrides.Num(); Index++)
            {
                if (Overrides[Index].ComponentName == InComponentName)
                {
                    return Index;
                }
            }
            return INDEX_NONE;
        }
        struct FOverride
        {
            FName ComponentName;
            const UClass* ComponentClass = nullptr;
            TUniquePtr<FOverrides> SubOverrides;
            bool bDoNotCreate = false;
            FOverride(FName InComponentName)
                : ComponentName(InComponentName)
            {
            }
 
            FOverride& operator=(const FOverride& Other)
            {
                ComponentName = Other.ComponentName;
                ComponentClass = Other.ComponentClass;
                SubOverrides = (Other.SubOverrides ? MakeUnique<FOverrides>(*Other.SubOverrides) : nullptr);
                bDoNotCreate = Other.bDoNotCreate;
                return *this;
            }
 
            FOverride(const FOverride& Other)
            {
                *this = Other;
            }
 
            FOverride(FOverride&&) = default;
            FOverride& operator=(FOverride&&) = default;
        };
        TArray<FOverride, TInlineAllocator<8> > Overrides;
    };
    struct FSubobjectsToInit
    {
        void Add(UObject* Subobject, UObject* Template)
        {
            for (int32 Index = 0; Index < SubobjectInits.Num(); Index++)
            {
                check(SubobjectInits[Index].Subobject != Subobject);
            }
            SubobjectInits.Emplace(Subobject, Template);
        }
        struct FSubobjectInit
        {
            UObject* Subobject;
            UObject* Template;
            FSubobjectInit(UObject* InSubobject, UObject* InTemplate)
                : Subobject(InSubobject)
                , Template(InTemplate)
            {
            }
        };
        TArray<FSubobjectInit, TInlineAllocator<8> > SubobjectInits;
    };
 
    COREUOBJECT_API void AssertIfSubobjectSetupIsNotAllowed(const FName SubobjectName) const;
 
    COREUOBJECT_API void AssertIfSubobjectSetupIsNotAllowed(FStringView SubobjectName) const;
 
    COREUOBJECT_API void AssertIfSubobjectSetupIsNotAllowed(TArrayView<const FName> SubobjectNames) const;
 
    UObject* Obj;
    UObject* ObjectArchetype;
    bool bCopyTransientsFromClassDefaults;
    bool bShouldInitializePropsFromArchetype;
    bool bSubobjectClassInitializationAllowed = true;
#if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
    bool bIsDeferredInitializer = false;
#endif // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING
    struct FObjectInstancingGraph* InstanceGraph;
    mutable FOverrides SubobjectOverrides;
    mutable FSubobjectsToInit ComponentInits;
#if !UE_BUILD_SHIPPING
    mutable TArray<FName, TInlineAllocator<8>> ConstructedSubobjects;
#endif
    UObject* LastConstructedObject = nullptr;
 
    TFunction<void()> PropertyInitCallback;
    TArray<TFunction<void()>> PropertyPostInitCallbacks;
 
    friend struct FStaticConstructObjectParameters;
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API void OnGCObjectCreated(FGCObject* InObject);
 
    FDelegateHandle OnGCObjectCreatedHandle;
    TArray<FGCObject*> CreatedGCObjects;
#endif // WITH_EDITORONLY_DATA
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
public:
    UE_DEPRECATED(5.7, "Use FRemoteObjectConstructionOverridesScope instead.")
    UE::RemoteObject::Serialization::FRemoteObjectConstructionOverrides* GetRemoteSubObjectOverrides() const
    {
        return nullptr;
    }
#endif // UE_WITH_REMOTE_OBJECT_HANDLE
};
 
struct FStaticConstructObjectParameters
{
    const UClass* Class;
 
    UObject* Outer;
 
    FName Name;
 
    EObjectFlags SetFlags = RF_NoFlags;
 
    EInternalObjectFlags InternalSetFlags = EInternalObjectFlags::None;
 
    bool bCopyTransientsFromClassDefaults = false;
 
    bool bAssumeTemplateIsArchetype = false;
 
    UObject* Template = nullptr;
 
    FObjectInstancingGraph* InstanceGraph = nullptr;
 
    UPackage* ExternalPackage = nullptr;
 
    TFunction<void()> PropertyInitCallback;
 
    int32 SerialNumber = 0;
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    FRemoteObjectId RemoteId;
 
    UE_DEPRECATED(5.7, "Use FRemoteObjectConstructionOverridesScope instead.")
    UE::RemoteObject::Serialization::FRemoteObjectConstructionOverrides* RemoteSubObjectOverrides = nullptr;
#endif // UE_WITH_REMOTE_OBJECT_HANDLE
 
private:
    FObjectInitializer::FOverrides* SubobjectOverrides = nullptr;
 
public:
 
    COREUOBJECT_API FStaticConstructObjectParameters(const UClass* InClass);
 
    friend FObjectInitializer;
};
 
class FScriptIntegrationObjectHelper
{
public:
    inline static void InitProperties(const FObjectInitializer& ObjectInitializer, UObject* Obj, UClass* DefaultsClass, UObject* DefaultData)
    {
        FObjectInitializer::InitProperties(Obj, DefaultsClass, DefaultData, ObjectInitializer.bCopyTransientsFromClassDefaults);
    }
 
    inline static bool InitSubobjectProperties(const FObjectInitializer& ObjectInitializer)
    {
        return ObjectInitializer.InitSubobjectProperties(ObjectInitializer.IsInstancingAllowed());
    }
 
    inline static void InstanceSubobjects(const FObjectInitializer& ObjectInitializer, UClass* Class, bool bNeedInstancing, bool bNeedSubobjectInstancing)
    {
        ObjectInitializer.InstanceSubobjects(Class, bNeedInstancing, bNeedSubobjectInstancing);
    }
 
    inline static void PostConstructInitObject(FObjectInitializer& ObjectInitializer)
    {
        ObjectInitializer.PostConstructInit();
    }
};
 
#if DO_CHECK
COREUOBJECT_API void CheckIsClassChildOf_Internal(const UClass* Parent, const UClass* Child);
#endif
 
template< class T >
FUNCTION_NON_NULL_RETURN_START
    T* NewObject(UObject* Outer, const UClass* Class, FName Name = NAME_None, EObjectFlags Flags = RF_NoFlags, UObject* Template = nullptr, bool bCopyTransientsFromClassDefaults = false, FObjectInstancingGraph* InInstanceGraph = nullptr, UPackage* InExternalPackage = nullptr)
FUNCTION_NON_NULL_RETURN_END
{
    if (Name == NAME_None)
    {
        FObjectInitializer::AssertIfInConstructor(Outer, TEXT("NewObject with empty name can't be used to create default subobjects (inside of UObject derived class constructor) as it produces inconsistent object names. Use ObjectInitializer.CreateDefaultSubobject<> instead."));
    }
 
#if DO_CHECK
    // Class was specified explicitly, so needs to be validated
    CheckIsClassChildOf_Internal(T::StaticClass(), Class);
#endif
 
    FStaticConstructObjectParameters Params(Class);
    Params.Outer = Outer;
    Params.Name = Name;
    Params.SetFlags = Flags;
    Params.Template = Template;
    Params.bCopyTransientsFromClassDefaults = bCopyTransientsFromClassDefaults;
    Params.InstanceGraph = InInstanceGraph;
    Params.ExternalPackage = InExternalPackage;
 
    T* Result = static_cast<T*>(StaticConstructObject_Internal(Params));
    return Result;
}
 
template< class T >
FUNCTION_NON_NULL_RETURN_START
    T* NewObject(UObject* Outer = GetTransientPackageAsObject())
FUNCTION_NON_NULL_RETURN_END
{
    // Name is always None for this case
    FObjectInitializer::AssertIfInConstructor(Outer, TEXT("NewObject with empty name can't be used to create default subobjects (inside of UObject derived class constructor) as it produces inconsistent object names. Use ObjectInitializer.CreateDefaultSubobject<> instead."));
 
    FStaticConstructObjectParameters Params(T::StaticClass());
    Params.Outer = Outer;
 
    T* Result = static_cast<T*>(StaticConstructObject_Internal(Params));
    return Result;
}
 
template< class T >
FUNCTION_NON_NULL_RETURN_START
    T* NewObject(UObject* Outer, FName Name, EObjectFlags Flags = RF_NoFlags, UObject* Template = nullptr, bool bCopyTransientsFromClassDefaults = false, FObjectInstancingGraph* InInstanceGraph = nullptr, UPackage* InExternalPackage = nullptr)
FUNCTION_NON_NULL_RETURN_END
{
    if (Name == NAME_None)
    {
        FObjectInitializer::AssertIfInConstructor(Outer, TEXT("NewObject with empty name can't be used to create default subobjects (inside of UObject derived class constructor) as it produces inconsistent object names. Use ObjectInitializer.CreateDefaultSubobject<> instead."));
    }
 
    FStaticConstructObjectParameters Params(T::StaticClass());
    Params.Outer = Outer;
    Params.Name = Name;
    Params.SetFlags = Flags;
    Params.Template = Template;
    Params.bCopyTransientsFromClassDefaults = bCopyTransientsFromClassDefaults;
    Params.InstanceGraph = InInstanceGraph;
    Params.ExternalPackage = InExternalPackage;
 
    T* Result = static_cast<T*>(StaticConstructObject_Internal(Params));
    return Result;
}
 
COREUOBJECT_API UObject* DuplicateObject_Internal(UClass* Class, const UObject* SourceObject, UObject* Outer, const FName NAME_None);
 
template< class T >
T* DuplicateObject(T const* SourceObject,UObject* Outer, const FName Name = NAME_None)
{
    return static_cast<T*>(DuplicateObject_Internal(T::StaticClass(), SourceObject, Outer, Name));
}
 
template <typename T>
T* DuplicateObject(const TObjectPtr<T>& SourceObject,UObject* Outer, const FName Name = NAME_None)
{
    return static_cast<T*>(DuplicateObject_Internal(T::StaticClass(), SourceObject, Outer, Name));
}
 
COREUOBJECT_API bool UsesPerObjectConfig( UObject* SourceObject );
 
COREUOBJECT_API FString GetConfigFilename( UObject* SourceObject );
 
/*----------------------------------------------------------------------------
    Core templates.
----------------------------------------------------------------------------*/
 
template< class T > 
inline bool ParseObject( const TCHAR* Stream, const TCHAR* Match, T*& Obj, UObject* Outer, EParseObjectLoadingPolicy LoadingPolicy, bool* bInvalidObject=nullptr )
{
    return ParseObject( Stream, Match, T::StaticClass(), (UObject*&)Obj, Outer, LoadingPolicy, bInvalidObject );
}
template< class T > 
inline bool ParseObject( const TCHAR* Stream, const TCHAR* Match, T*& Obj, UObject* Outer, bool* bInvalidObject=nullptr )
{
    return ParseObject( Stream, Match, T::StaticClass(), (UObject*&)Obj, Outer, EParseObjectLoadingPolicy::Find, bInvalidObject );
}
 
template< class T >
inline T* FindObjectFast(UObject* Outer, FName Name, EFindObjectFlags Flags = EFindObjectFlags::None, EObjectFlags ExclusiveFlags = RF_NoFlags)
{
    return (T*)StaticFindObjectFast(T::StaticClass(), Outer, Name, Flags, ExclusiveFlags);
}
template <typename T, UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("FindObjectFast")
UE_NODEBUG UE_FORCEINLINE_HINT T* FindObjectFast(UObject* Outer, FName Name, ExactClassType bExactClass, EObjectFlags ExclusiveFlags = RF_NoFlags)
{
    return FindObjectFast<T>(Outer, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, ExclusiveFlags);
}
 
template< class T > 
inline T* FindObject( UObject* Outer, FStringView Name, EFindObjectFlags Flags = EFindObjectFlags::None )
{
    return (T*)StaticFindObject( T::StaticClass(), Outer, Name, Flags );
}
template <typename T, UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("FindObject")
UE_NODEBUG UE_FORCEINLINE_HINT T* FindObject(UObject* Outer, FStringView Name, ExactClassType bExactClass)
{
    return FindObject<T>(Outer, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
template< class T >
inline T* FindObject(FTopLevelAssetPath InPath, EFindObjectFlags Flags = EFindObjectFlags::None)
{
    return (T*)StaticFindObject(T::StaticClass(), InPath, Flags);
}
template <typename T, UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("FindObject")
UE_NODEBUG UE_FORCEINLINE_HINT T* FindObject(FTopLevelAssetPath InPath, ExactClassType bExactClass)
{
    return FindObject<T>(InPath, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
template< class T > 
inline T* FindObjectChecked( UObject* Outer, FStringView Name, EFindObjectFlags Flags = EFindObjectFlags::None )
{
    return (T*)StaticFindObjectChecked( T::StaticClass(), Outer, Name, Flags );
}
template <typename T, UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("FindObjectChecked")
UE_NODEBUG UE_FORCEINLINE_HINT T* FindObjectChecked( UObject* Outer, FStringView Name, ExactClassType bExactClass )
{
    return FindObjectChecked<T>(Outer, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
template< class T > 
inline T* FindObjectSafe( UObject* Outer, FStringView Name, EFindObjectFlags Flags = EFindObjectFlags::None )
{
    return (T*)StaticFindObjectSafe( T::StaticClass(), Outer, Name, Flags );
}
template <typename T, UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("FindObjectSafe")
UE_NODEBUG UE_FORCEINLINE_HINT T* FindObjectSafe( UObject* Outer, FStringView Name, ExactClassType bExactClass )
{
    return FindObjectSafe<T>(Outer, Name, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
template< class T >
inline T* FindObjectSafe(FTopLevelAssetPath InPath, EFindObjectFlags Flags = EFindObjectFlags::None)
{
    return (T*)StaticFindObjectSafe(T::StaticClass(), InPath, Flags);
}
template <typename T, UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("FindObjectSafe")
UE_NODEBUG UE_FORCEINLINE_HINT T* FindObjectSafe(FTopLevelAssetPath InPath, ExactClassType bExactClass)
{
    return FindObjectSafe<T>(InPath, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None);
}
 
template< class T >
inline T* FindFirstObject(FStringView Name, EFindFirstObjectOptions Options = EFindFirstObjectOptions::None, ELogVerbosity::Type AmbiguousMessageVerbosity = ELogVerbosity::NoLogging, const TCHAR* CurrentOperation = nullptr)
{
    return (T*)StaticFindFirstObject(T::StaticClass(), Name, Options, AmbiguousMessageVerbosity, CurrentOperation);
}
 
template< class T >
inline T* FindFirstObjectSafe(FStringView Name, EFindFirstObjectOptions Options = EFindFirstObjectOptions::None, ELogVerbosity::Type AmbiguousMessageVerbosity = ELogVerbosity::NoLogging, const TCHAR* CurrentOperation = nullptr)
{
    return (T*)StaticFindFirstObjectSafe(T::StaticClass(), Name, Options, AmbiguousMessageVerbosity, CurrentOperation);
}
 
template< class T > 
inline T* LoadObject( UObject* Outer, FStringView Name, FStringView Filename={}, uint32 LoadFlags=LOAD_None, UPackageMap* Sandbox=nullptr, const FLinkerInstancingContext* InstancingContext=nullptr )
{
    return (T*)StaticLoadObject( T::StaticClass(), Outer, Name, Filename, LoadFlags, Sandbox, true, InstancingContext );
}
 
template< class T > 
inline UClass* LoadClass( UObject* Outer, FStringView Name, FStringView Filename={}, uint32 LoadFlags=LOAD_None, UPackageMap* Sandbox=nullptr )
{
    return StaticLoadClass( T::StaticClass(), Outer, Name, Filename, LoadFlags, Sandbox );
}
 
template< class T > 
inline const T* GetDefault()
{
    return (const T*)T::StaticClass()->GetDefaultObject();
}
 
template< class T > 
inline const T* GetDefault(const UClass* Class);
 
template< class T >
inline T* GetMutableDefault()
{
    return (T*)T::StaticClass()->GetDefaultObject();
}
 
template< class T > 
inline T* GetMutableDefault(UClass *Class);
 
template< class T >
inline bool IsClassLoaded()
{
    return T::StaticClass()->GetDefaultObject(false) != nullptr;
}
 
COREUOBJECT_API UFunction* FindDelegateSignature(FName DelegateSignatureName);
 
template <class T>
bool ContainsObjectOfClass( const TArray<T*>& ObjectArray, UClass* ClassToCheck, EFindObjectFlags Flags = EFindObjectFlags::None, TArray<T*>* out_Objects=nullptr )
{
    bool bResult = false;
    for ( int32 ArrayIndex = 0; ArrayIndex < ObjectArray.Num(); ArrayIndex++ )
    {
        if ( ObjectArray[ArrayIndex] != nullptr )
        {
            bool bMatchesSearchCriteria = !!(Flags & EFindObjectFlags::ExactClass)
                ? ObjectArray[ArrayIndex]->GetClass() == ClassToCheck
                : ObjectArray[ArrayIndex]->IsA(ClassToCheck);
 
            if ( bMatchesSearchCriteria )
            {
                bResult = true;
                if ( out_Objects != nullptr )
                {
                    out_Objects->Add(ObjectArray[ArrayIndex]);
                }
                else
                {
                    // if we don't need a list of objects that match the search criteria, we can stop as soon as we find at least one object of that class
                    break;
                }
            }
        }
    }
 
    return bResult;
}
template <typename T, UE::CSameAs<bool> ExactClassType>
UE_EXACTCLASS_BOOL_DEPRECATED("ContainsObjectOfClass")
UE_NODEBUG UE_FORCEINLINE_HINT bool ContainsObjectOfClass( const TArray<T*>& ObjectArray, UClass* ClassToCheck, ExactClassType bExactClass, TArray<T*>* out_Objects=nullptr )
{
    return ContainsObjectOfClass(ObjectArray, ClassToCheck, bExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None, out_Objects );
}
 
class FScopedObjectFlagMarker
{
    struct FStoredObjectFlags
    {
        FStoredObjectFlags()
        : Flags(RF_NoFlags)
        , InternalFlags(EInternalObjectFlags::None)
        {}
        FStoredObjectFlags(EObjectFlags InFlags, EInternalObjectFlags InInternalFlags)
            : Flags(InFlags)
            , InternalFlags(InInternalFlags)
        {}
        EObjectFlags Flags;
        EInternalObjectFlags InternalFlags;
    };
 
    TMap<UObject*, FStoredObjectFlags> StoredObjectFlags;
    
    void SaveObjectFlags();
 
    void RestoreObjectFlags();
 
public:
    FScopedObjectFlagMarker()
    {
        SaveObjectFlags();
    }
 
    ~FScopedObjectFlagMarker()
    {
        RestoreObjectFlags();
    }
};
 
 
template<class TObjectClass>
class TObjectArrayIterator
{
    /* sample code
    TArray<APawn *> TestPawns;
    ...
    // test iterator, all items
    for ( TObjectArrayIterator<APawn> It(TestPawns); It; ++It )
    {
        UE_LOG(LogUObjectGlobals, Log, TEXT("Item %s"),*It->GetFullName());
    }
    */
public:
    inline TObjectArrayIterator( TArray<TObjectClass*>& InArray, UClass* InClassToCheck = nullptr, EFindObjectFlags InFlags = EFindObjectFlags::None) : 
        Array(InArray),
        Index(-1),
        ClassToCheck(InClassToCheck),
        Flags(InFlags)
    {
        Advance();
    }
    template <UE::CSameAs<bool> ExactClassType>
    UE_EXACTCLASS_BOOL_DEPRECATED("TObjectArrayIterator")
    UE_NODEBUG UE_FORCEINLINE_HINT TObjectArrayIterator( TArray<TObjectClass*>& InArray, UClass* InClassToCheck, ExactClassType bInExactClass)
        : TObjectArrayIterator(InArray, InClassToCheck, bInExactClass ? EFindObjectFlags::ExactClass : EFindObjectFlags::None)
    {
    }
    UE_FORCEINLINE_HINT void operator++()
    {
        Advance();
    }
    UE_FORCEINLINE_HINT explicit operator bool() const
    { 
        return Index < Array.Num(); 
    }
    UE_FORCEINLINE_HINT bool operator !() const 
    {
        return !(bool)*this;
    }
 
    inline TObjectClass& operator*() const
    {
        checkSlow(GetObject());
        return *GetObject();
    }
    inline TObjectClass* operator->() const
    {
        checkSlow(GetObject());
        return GetObject();
    }
 
    UE_FORCEINLINE_HINT void RemoveCurrent()
    {
        Array.RemoveAt(Index--);
    }
    UE_FORCEINLINE_HINT void RemoveCurrentSwap()
    {
        Array.RemoveSwap(Index--);
    }
 
protected:
    UE_FORCEINLINE_HINT TObjectClass* GetObject() const 
    { 
        return Array(Index);
    }
    inline bool Advance()
    {
        while(++Index < Array.Num())
        {
            TObjectClass* At = GetObject();
            if (
                IsValid(At) && 
                (!ClassToCheck ||
                    (!!(Flags & EFindObjectFlags::ExactClass)
                        ? At->GetClass() == ClassToCheck
                        : At->IsA(ClassToCheck)))
                )
            {
                return true;
            }
        }
        return false;
    }
private:
    TArray<TObjectClass*>&  Array;
    int32                   Index;
    UClass*                 ClassToCheck;
    EFindObjectFlags        Flags;
};
 
class FReferenceCollectorArchive : public FArchiveUObject
{
    const UObject* SerializingObject = nullptr;
    const UObject* SerializedDataContainer  = nullptr;
    class FReferenceCollector& Collector;
 
protected:
    UE_FORCEINLINE_HINT class FReferenceCollector& GetCollector()
    {
        return Collector;
    }
 
public:
    // Constructor not COREUOBJECT-exported because constructing this class is for internal use only
    FReferenceCollectorArchive(const UObject* InSerializingObject, FReferenceCollector& InCollector);
 
    void SetSerializingObject(const UObject* InSerializingObject)
    {
        SerializingObject = InSerializingObject;
    }
    const UObject* GetSerializingObject() const
    {
        return SerializingObject;
    }
    void SetSerializedDataContainer(const UObject* InDataContainer)
    {
        SerializedDataContainer = InDataContainer;
    }
    const UObject* GetSerializedDataContainer() const
    {
        return SerializedDataContainer;
    }
 
    COREUOBJECT_API virtual FArchive& operator<<(UObject*& Object) override;
    COREUOBJECT_API virtual FArchive& operator<<(FObjectPtr& Object) override;
};
 
class FVerySlowReferenceCollectorArchiveScope
{   
    FReferenceCollectorArchive& Archive;
    const UObject* OldSerializingObject;
    FProperty* OldSerializedProperty;
    const UObject* OldSerializedDataContainer;
 
public:
    FVerySlowReferenceCollectorArchiveScope(FReferenceCollectorArchive& InArchive, const UObject* InSerializingObject, FProperty* InSerializedProperty = nullptr, const UObject* InSerializedDataContainer = nullptr)
        : Archive(InArchive)
        , OldSerializingObject(InArchive.GetSerializingObject())
        , OldSerializedProperty(InArchive.GetSerializedProperty())
        , OldSerializedDataContainer(InArchive.GetSerializedDataContainer())
    {
        Archive.SetSerializingObject(InSerializingObject);
        Archive.SetSerializedProperty(InSerializedProperty);
        Archive.SetSerializedDataContainer(InSerializedDataContainer);
    }
    ~FVerySlowReferenceCollectorArchiveScope()
    {
        Archive.SetSerializingObject(OldSerializingObject);
        Archive.SetSerializedProperty(OldSerializedProperty);
        Archive.SetSerializedDataContainer(OldSerializedDataContainer);
    }
    FReferenceCollectorArchive& GetArchive()
    {
        return Archive;
    }
};
 
class FReferenceCollector
{
public:
    COREUOBJECT_API virtual ~FReferenceCollector();
    
    COREUOBJECT_API virtual void AddStableReference(TObjectPtr<UObject>* Object);
    
    COREUOBJECT_API virtual void AddStableReferenceArray(TArray<TObjectPtr<UObject>>* Objects);
 
    COREUOBJECT_API virtual void AddStableReferenceSet(TSet<TObjectPtr<UObject>>* Objects);
 
    template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
    inline void AddStableReferenceMap(TMapBase<KeyType, ValueType, Allocator, KeyFuncs>& Map)
    {
#if UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR
        static constexpr bool bKeyReference = TIsTObjectPtr<KeyType>::Value;
        static constexpr bool bValueReference = TIsTObjectPtr<ValueType>::Value;
        static_assert(bKeyReference || bValueReference);
        static_assert(!(std::is_pointer_v<KeyType> && std::is_convertible_v<KeyType, const UObjectBase*>));
        static_assert(!(std::is_pointer_v<ValueType> && std::is_convertible_v<ValueType, const UObjectBase*>));
#else        
        static constexpr bool bKeyReference =   std::is_convertible_v<KeyType, const UObjectBase*>;
        static constexpr bool bValueReference = std::is_convertible_v<ValueType, const UObjectBase*>;
        static_assert(bKeyReference || bValueReference, "Key or value must be pointer to fully-defined UObject type");
#endif
        
        for (TPair<KeyType, ValueType>& Pair : Map)
        {
            if constexpr (bKeyReference)
            {
                AddStableReference(&Pair.Key);
            }
            if constexpr (bValueReference)
            {
                AddStableReference(&Pair.Value);
            }
        }
    }
 
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()
    COREUOBJECT_API virtual void AddStableReference(UObject** Object);
    
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()
    COREUOBJECT_API virtual void AddStableReferenceArray(TArray<UObject*>* Objects);
 
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()   
    COREUOBJECT_API virtual void AddStableReferenceSet(TSet<UObject*>* Objects);
    
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()   
    inline void AddStableReference(UObjectType** Object)
    {
        static_assert(sizeof(UObjectType) > 0, "Element must be a pointer to a fully-defined type");
        static_assert(std::is_convertible_v<UObjectType*, const UObjectBase*>, "Element must be a pointer to a type derived from UObject");
        AddStableReference(reinterpret_cast<UObject**>(Object));
    }
 
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()       
    inline void AddStableReferenceArray(TArray<UObjectType*>* Objects)
    {
        static_assert(sizeof(UObjectType) > 0, "Element must be a pointer to a fully-defined type");
        static_assert(std::is_convertible_v<UObjectType*, const UObjectBase*>, "Element must be a pointer to a type derived from UObject");
        AddStableReferenceArray(reinterpret_cast<TArray<UObject*>*>(Objects)); 
    }
 
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()       
    inline void AddStableReferenceSet(TSet<UObjectType*>* Objects)
    {
        static_assert(sizeof(UObjectType) > 0, "Element must be a pointer to a fully-defined type");
        static_assert(std::is_convertible_v<UObjectType*, const UObjectBase*>, "Element must be a pointer to a type derived from UObject");
        AddStableReferenceSet(reinterpret_cast<TSet<UObject*>*>(Objects)); 
    }
 
    template<class UObjectType>
    UE_FORCEINLINE_HINT void AddStableReference(TObjectPtr<UObjectType>* Object)
    {
        AddStableReferenceFwd(reinterpret_cast<FObjectPtr*>(Object));
    }
 
    template<class UObjectType>
    UE_FORCEINLINE_HINT void AddStableReferenceArray(TArray<TObjectPtr<UObjectType>>* Objects)
    {
        AddStableReferenceArrayFwd(reinterpret_cast<TArray<FObjectPtr>*>(Objects));
    }
 
    template<class UObjectType>
    UE_FORCEINLINE_HINT void AddStableReferenceSet(TSet<TObjectPtr<UObjectType>>* Objects)
    {
        AddStableReferenceSetFwd(reinterpret_cast<TSet<FObjectPtr>*>(Objects));
    }
 
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()   
    void AddReferencedObject(UObjectType*& Object, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObject<UObjectType>(*this, Object, ReferencingObject, ReferencingProperty);
    }
 
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()       
    void AddReferencedObject(const UObjectType*& Object, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObject<UObjectType>(*this, Object, ReferencingObject, ReferencingProperty);
    }
 
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()       
    void AddReferencedObjects(TArray<UObjectType*>& ObjectArray, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObjects<UObjectType>(*this, ObjectArray, ReferencingObject, ReferencingProperty);
    }
 
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()   
    void AddReferencedObjects(TArray<const UObjectType*>& ObjectArray, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObjects<UObjectType>(*this, ObjectArray, ReferencingObject, ReferencingProperty);
    }
 
    template<class UObjectType>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()   
    void AddReferencedObjects(TSet<UObjectType*>& ObjectSet, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObjects<UObjectType>(*this, ObjectSet, ReferencingObject, ReferencingProperty);
    }
 
    template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()       
    void AddReferencedObjects(TMapBase<KeyType*, ValueType, Allocator, KeyFuncs>& Map, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObjects<KeyType, ValueType, Allocator, KeyFuncs>(*this, Map, ReferencingObject, ReferencingProperty);
    }
 
    template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()           
    void AddReferencedObjects(TMapBase<KeyType, ValueType*, Allocator, KeyFuncs>& Map, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObjects<KeyType, ValueType, Allocator, KeyFuncs>(*this, Map, ReferencingObject, ReferencingProperty);
    }
 
    template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()               
    void AddReferencedObjects(TMapBase<KeyType*, ValueType*, Allocator, KeyFuncs>& Map, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        AROPrivate::AddReferencedObjects<KeyType, ValueType, Allocator, KeyFuncs>(*this, Map, ReferencingObject, ReferencingProperty);
    }
 
    template<class UObjectType>
    void AddReferencedObject(TObjectPtr<UObjectType>& Object, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        if (IsObjectHandleResolved_ForGC(Object.GetHandle()))
        {
            HandleObjectReference(*reinterpret_cast<UObject**>(&Object), ReferencingObject, ReferencingProperty);
        }
    }
 
    template<class UObjectType>
    void AddReferencedObject(TObjectPtr<const UObjectType>& Object, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        static_assert(sizeof(UObjectType) > 0, "AddReferencedObject: Element must be a pointer to a fully-defined type");
        static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObject: Element must be a pointer to a type derived from UObject");
        if (IsObjectHandleResolved_ForGC(Object.GetHandle()))
        {
            HandleObjectReference(*reinterpret_cast<UObject**>(&Object), ReferencingObject, ReferencingProperty);
        }
    }
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    template<class VCellType>
    void AddReferencedVerseValue(Verse::TWriteBarrier<VCellType>& Value, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr);
 
    void AddReferencedVerseValue(Verse::VRestValue& Value, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr);
#endif
 
    template<class UObjectType>
    void AddReferencedObjects(TArray<TObjectPtr<UObjectType>>& ObjectArray, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        static_assert(sizeof(UObjectType) > 0, "AddReferencedObjects: Elements must be pointers to a fully-defined type");
        static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObjects: Elements must be pointers to a type derived from UObject");
        // Cannot use a reinterpret_cast due to MSVC (and not Clang) emitting a warning:
        // C4946: reinterpret_cast used between related classes: ...
        HandleObjectReferences((FObjectPtr*)(ObjectArray.GetData()), ObjectArray.Num(), ReferencingObject, ReferencingProperty);
    }
 
    template<class UObjectType>
    void AddReferencedObjects(TArray<TObjectPtr<const UObjectType>>& ObjectArray, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        static_assert(sizeof(UObjectType) > 0, "AddReferencedObjects: Elements must be pointers to a fully-defined type");
        static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObjects: Elements must be pointers to a type derived from UObject");
        // Cannot use a reinterpret_cast due to MSVC (and not Clang) emitting a warning:
        // C4946: reinterpret_cast used between related classes: ...
        HandleObjectReferences((FObjectPtr*)(ObjectArray.GetData()), ObjectArray.Num(), ReferencingObject, ReferencingProperty);
    }
 
    template<class UObjectType>
    void AddReferencedObjects(TSet<TObjectPtr<UObjectType>>& ObjectSet, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        static_assert(sizeof(UObjectType) > 0, "AddReferencedObjects: Elements must be pointers to a fully-defined type");
        static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObjects: Elements must be pointers to a type derived from UObject");
        for (auto& Object : ObjectSet)
        {
            if (IsObjectHandleResolved_ForGC(Object.GetHandle()))
            {
                HandleObjectReference(*reinterpret_cast<UObject**>(&Object), ReferencingObject, ReferencingProperty);
            }
        }
    }
 
    template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
    void AddReferencedObjects(TMapBase<TObjectPtr<KeyType>, ValueType, Allocator, KeyFuncs>& Map, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        static_assert(sizeof(KeyType) > 0, "AddReferencedObjects: Keys must be pointers to a fully-defined type");
        static_assert(TPointerIsConvertibleFromTo<KeyType, const UObjectBase>::Value, "AddReferencedObjects: Keys must be pointers to a type derived from UObject");
        static_assert(!UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR ||
                                    !(std::is_pointer_v<ValueType> && std::is_convertible_v<ValueType, const UObjectBase*>));
        for (auto& It : Map)
        {
            if (IsObjectHandleResolved_ForGC(It.Key.GetHandle()))
            {
                HandleObjectReference(*reinterpret_cast<UObject**>(&It.Key), ReferencingObject, ReferencingProperty);
            }
        }
    }
    template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
    void AddReferencedObjects(TMapBase<KeyType, TObjectPtr<ValueType>, Allocator, KeyFuncs>& Map, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        static_assert(sizeof(ValueType) > 0, "AddReferencedObjects: Values must be pointers to a fully-defined type");
        static_assert(TPointerIsConvertibleFromTo<ValueType, const UObjectBase>::Value, "AddReferencedObjects: Values must be pointers to a type derived from UObject");
        static_assert(!UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR ||
                                    !(std::is_pointer_v<KeyType> && std::is_convertible_v<KeyType, const UObjectBase*>));
        for (auto& It : Map)
        {
            if (IsObjectHandleResolved_ForGC(It.Value.GetHandle()))
            {
                HandleObjectReference(*reinterpret_cast<UObject**>(&It.Value), ReferencingObject, ReferencingProperty);
            }
        }
    }
    template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
    void AddReferencedObjects(TMapBase<TObjectPtr<KeyType>, TObjectPtr<ValueType>, Allocator, KeyFuncs>& Map, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
    {
        static_assert(sizeof(KeyType) > 0, "AddReferencedObjects: Keys must be pointers to a fully-defined type");
        static_assert(sizeof(ValueType) > 0, "AddReferencedObjects: Values must be pointers to a fully-defined type");
        static_assert(TPointerIsConvertibleFromTo<KeyType, const UObjectBase>::Value, "AddReferencedObjects: Keys must be pointers to a type derived from UObject");
        static_assert(TPointerIsConvertibleFromTo<ValueType, const UObjectBase>::Value, "AddReferencedObjects: Values must be pointers to a type derived from UObject");
        for (auto& It : Map)
        {
            if (IsObjectHandleResolved_ForGC(It.Key.GetHandle()))
            {
                HandleObjectReference(*reinterpret_cast<UObject**>(&It.Key), ReferencingObject, ReferencingProperty);
            }
            if (IsObjectHandleResolved_ForGC(It.Value.GetHandle()))
            {
                HandleObjectReference(*reinterpret_cast<UObject**>(&It.Value), ReferencingObject, ReferencingProperty);
            }
        }
    }
    
    template <typename T>
    void AddReferencedObject(TWeakObjectPtr<T>& P,
                                                     const UObject* ReferencingObject = nullptr,
                                                     const FProperty* ReferencingProperty = nullptr)
    {
        AddReferencedObject(reinterpret_cast<FWeakObjectPtr&>(P),
                                                ReferencingObject,
                                                ReferencingProperty);
    }
 
    COREUOBJECT_API void AddReferencedObject(FWeakObjectPtr& P,
                                                     const UObject* ReferencingObject = nullptr,
                                                     const FProperty* ReferencingProperty = nullptr);
 
    UE_REFERENCE_COLLECTOR_REQUIRE_OBJECTPTR_DEPRECATED()               
    COREUOBJECT_API void AddReferencedObjects(const UScriptStruct*& ScriptStruct, void* Instance, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr);
 
    COREUOBJECT_API void AddReferencedObjects(TObjectPtr<const UScriptStruct>& ScriptStruct, void* Instance, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr);
    COREUOBJECT_API void AddReferencedObjects(TWeakObjectPtr<const UScriptStruct>& ScriptStruct, void* Instance, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr);
    
    COREUOBJECT_API void AddPropertyReferences(const UStruct* Struct, void* Instance, const UObject* ReferencingObject = nullptr);
    
    COREUOBJECT_API void AddPropertyReferencesWithStructARO(const UScriptStruct* Struct, void* Instance, const UObject* ReferencingObject = nullptr);
 
    COREUOBJECT_API void AddPropertyReferencesWithStructARO(const UClass* Class, void* Instance, const UObject* ReferencingObject = nullptr);
 
    COREUOBJECT_API void AddPropertyReferencesLimitedToObjectProperties(const UStruct* Struct, void* Instance, const UObject* ReferencingObject = nullptr);
 
    virtual bool NeedsPropertyReferencer() const { return true; }
 
    virtual bool IsIgnoringArchetypeRef() const = 0;
    virtual bool IsIgnoringTransient() const = 0;
    virtual void AllowEliminatingReferences(bool bAllow) {}
 
 
    virtual void SetSerializedProperty(class FProperty* Inproperty) {}
    virtual class FProperty* GetSerializedProperty() const { return nullptr; }
    virtual bool MarkWeakObjectReferenceForClearing(UObject** WeakReference, UObject* ReferenceOwner) { return false; }
    virtual void SetIsProcessingNativeReferences(bool bIsNative) {}
    virtual bool IsProcessingNativeReferences() const { return true; }
 
    virtual bool NeedsInitialReferences() const { return true; }
 
    FReferenceCollectorArchive& GetVerySlowReferenceCollectorArchive()
    {
        if (!DefaultReferenceCollectorArchive)
        {
            CreateVerySlowReferenceCollectorArchive();
        }
        return *DefaultReferenceCollectorArchive;
    }
 
 
    struct AROPrivate final // nb: internal use only
    {
        template<class UObjectType>
        static void AddReferencedObject(FReferenceCollector& Coll,
                                                                        UObjectType*& Object, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
        {
            // @todo: should be uncommented when proper usage is fixed everywhere
            // static_assert(sizeof(UObjectType) > 0, "AddReferencedObject: Element must be a pointer to a fully-defined type");
            // static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObject: Element must be a pointer to a type derived from UObject");
            Coll.HandleObjectReference(*(UObject**)&Object, ReferencingObject, ReferencingProperty);
        }
 
        template<class UObjectType>
        static void AddReferencedObject(FReferenceCollector& Coll,
                                                                        const UObjectType*& Object,
                                                                        const UObject* ReferencingObject = nullptr,
                                                                        const FProperty* ReferencingProperty = nullptr)
        {
            // @todo: should be uncommented when proper usage is fixed everywhere
            // static_assert(sizeof(UObjectType) > 0, "AddReferencedObject: Element must be a pointer to a fully-defined type");
            // static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObject: Element must be a pointer to a type derived from UObject");
            Coll.HandleObjectReference(*(UObject**)const_cast<UObjectType**>(&Object), ReferencingObject, ReferencingProperty);
        }
 
        template<class UObjectType>
        static void AddReferencedObjects(FReferenceCollector& Coll,
                                                                         TArray<UObjectType*>& ObjectArray,
                                                                         const UObject* ReferencingObject = nullptr,
                                                                         const FProperty* ReferencingProperty = nullptr)
        {
            static_assert(sizeof(UObjectType) > 0, "AddReferencedObjects: Elements must be pointers to a fully-defined type");
            static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObjects: Elements must be pointers to a type derived from UObject");
            Coll.HandleObjectReferences(reinterpret_cast<UObject**>(ObjectArray.GetData()), ObjectArray.Num(), ReferencingObject, ReferencingProperty);
        }
        
        template<class UObjectType>
        static void AddReferencedObjects(FReferenceCollector& Coll,
                                                                         TArray<const UObjectType*>& ObjectArray,
                                                                         const UObject* ReferencingObject = nullptr,
                                                                         const FProperty* ReferencingProperty = nullptr)
        {
            static_assert(sizeof(UObjectType) > 0, "AddReferencedObjects: Elements must be pointers to a fully-defined type");
            static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObjects: Elements must be pointers to a type derived from UObject");
            Coll.HandleObjectReferences(reinterpret_cast<UObject**>(const_cast<UObjectType**>(ObjectArray.GetData())), ObjectArray.Num(), ReferencingObject, ReferencingProperty);
        }
 
        template<class UObjectType>
        static void AddReferencedObjects(FReferenceCollector& Coll,
                                                                         TSet<UObjectType*>& ObjectSet,
                                                                         const UObject* ReferencingObject = nullptr,
                                                                         const FProperty* ReferencingProperty = nullptr)
        {
            static_assert(sizeof(UObjectType) > 0, "AddReferencedObjects: Elements must be pointers to a fully-defined type");
            static_assert(TPointerIsConvertibleFromTo<UObjectType, const UObjectBase>::Value, "AddReferencedObjects: Elements must be pointers to a type derived from UObject");
            for (auto& Object : ObjectSet)
            {
                Coll.HandleObjectReference(*(UObject**)&Object, ReferencingObject, ReferencingProperty);
            }
        }
    
        template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
        static void AddReferencedObjects(FReferenceCollector& Coll,
                                                                         TMapBase<KeyType*, ValueType, Allocator, KeyFuncs>& Map,
                                                                         const UObject* ReferencingObject = nullptr,
                                                                         const FProperty* ReferencingProperty = nullptr)
        {
            static_assert(sizeof(KeyType) > 0, "AddReferencedObjects: Keys must be pointers to a fully-defined type");
            static_assert(TPointerIsConvertibleFromTo<KeyType, const UObjectBase>::Value, "AddReferencedObjects: Keys must be pointers to a type derived from UObject");
            for (auto& It : Map)
            {
                Coll.HandleObjectReference(*(UObject**)&It.Key, ReferencingObject, ReferencingProperty);
            }
        }
 
        template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
        static void AddReferencedObjects(FReferenceCollector& Coll,
                                                                         TMapBase<KeyType, ValueType*, Allocator, KeyFuncs>& Map,
                                                                         const UObject* ReferencingObject = nullptr,
                                                                         const FProperty* ReferencingProperty = nullptr)
        {
            static_assert(sizeof(ValueType) > 0, "AddReferencedObjects: Values must be pointers to a fully-defined type");
            static_assert(TPointerIsConvertibleFromTo<ValueType, const UObjectBase>::Value, "AddReferencedObjects: Values must be pointers to a type derived from UObject");
            for (auto& It : Map)
            {
                Coll.HandleObjectReference(*(UObject**)&It.Value, ReferencingObject, ReferencingProperty);
            }
        }
 
        template <typename KeyType, typename ValueType, typename Allocator, typename KeyFuncs>
        static void AddReferencedObjects(FReferenceCollector& Coll, TMapBase<KeyType*, ValueType*, Allocator, KeyFuncs>& Map, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr)
        {
            static_assert(sizeof(KeyType) > 0, "AddReferencedObjects: Keys must be pointers to a fully-defined type");
            static_assert(sizeof(ValueType) > 0, "AddReferencedObjects: Values must be pointers to a fully-defined type");
            static_assert(TPointerIsConvertibleFromTo<KeyType, const UObjectBase>::Value, "AddReferencedObjects: Keys must be pointers to a type derived from UObject");
            static_assert(TPointerIsConvertibleFromTo<ValueType, const UObjectBase>::Value, "AddReferencedObjects: Values must be pointers to a type derived from UObject");
            for (auto& It : Map)
            {
                Coll.HandleObjectReference(*(UObject**)&It.Key, ReferencingObject, ReferencingProperty);
                Coll.HandleObjectReference(*(UObject**)&It.Value, ReferencingObject, ReferencingProperty);
            }
        }
 
        static void AddReferencedObjects(FReferenceCollector& Coll,
                                                                         const UScriptStruct*& ScriptStruct,
                                                                         void* Instance, const UObject* ReferencingObject = nullptr, const FProperty* ReferencingProperty = nullptr);
    };  
 
protected:
    virtual void HandleObjectReference(UObject*& InObject, const UObject* InReferencingObject, const FProperty* InReferencingProperty) = 0;
 
    virtual void HandleObjectReferences(UObject** InObjects, const int32 ObjectNum, const UObject* InReferencingObject, const FProperty* InReferencingProperty)
    {
        for (int32 ObjectIndex = 0; ObjectIndex < ObjectNum; ++ObjectIndex)
        {
            UObject*& Object = InObjects[ObjectIndex];
            HandleObjectReference(Object, InReferencingObject, InReferencingProperty);
        }
    }
 
    COREUOBJECT_API virtual void HandleObjectReferences(FObjectPtr* InObjects, const int32 ObjectNum, const UObject* InReferencingObject, const FProperty* InReferencingProperty);
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
    virtual void HandleVCellReference(Verse::VCell* InCell, const UObject* InReferencingObject, const FProperty* InReferencingProperty)
    {
        // Ignore VCells by default, like `FSimpleReferenceProcessorBase::HandleTokenStreamVerseCellReference`.
    }
#endif
 
private:
    COREUOBJECT_API void CreateVerySlowReferenceCollectorArchive();
 
    TUniquePtr<FReferenceCollectorArchive> DefaultReferenceCollectorArchive;
 
    COREUOBJECT_API void AddStableReferenceSetFwd(TSet<FObjectPtr>* Objects);    
    COREUOBJECT_API void AddStableReferenceArrayFwd(TArray<FObjectPtr>* Objects);       
    COREUOBJECT_API void AddStableReferenceFwd(FObjectPtr* Object);  
};
 
class FReferenceFinder : public FReferenceCollector
{
public:
 
    COREUOBJECT_API FReferenceFinder(TArray<UObject*>& InObjectArray, UObject* InOuter = nullptr, bool bInRequireDirectOuter = true, bool bInShouldIgnoreArchetype = false, bool bInSerializeRecursively = false, bool bInShouldIgnoreTransient = false);
 
    COREUOBJECT_API ~FReferenceFinder();
    COREUOBJECT_API virtual void FindReferences(UObject* Object, UObject* ReferencingObject = nullptr, FProperty* ReferencingProperty = nullptr);
 
    // FReferenceCollector interface.
    COREUOBJECT_API virtual void HandleObjectReference(UObject*& Object, const UObject* ReferencingObject, const FProperty* InReferencingProperty) override;
    virtual bool IsIgnoringArchetypeRef() const override { return bShouldIgnoreArchetype; }
    virtual bool IsIgnoringTransient() const override { return bShouldIgnoreTransient; }
    virtual void SetSerializedProperty(class FProperty* Inproperty) override
    {
        SerializedProperty = Inproperty;
    }
    virtual class FProperty* GetSerializedProperty() const override
    {
        return SerializedProperty;
    }
protected:
 
    TArray<UObject*>&       ObjectArray;
    TSet<const UObject*>    ObjectSet;
    UObject*        LimitOuter;
    class FProperty* SerializedProperty;
    bool            bRequireDirectOuter;
    bool            bShouldIgnoreArchetype;
    bool            bSerializeRecursively;
    bool            bShouldIgnoreTransient;
};
 
enum class EPackageReloadPhase : uint8;
class FGarbageCollectionTracer;
class FPackageReloadedEvent;
 
enum class EHotReloadedClassFlags
{
    None = 0,
 
    // Set when the hot reloaded class has been detected as changed
    Changed = 0x01
};
 
ENUM_CLASS_FLAGS(EHotReloadedClassFlags)
 
enum class EReloadCompleteReason
{
    None,
    HotReloadAutomatic,
    HotReloadManual,
};
 
struct FEndLoadPackageContext
{
    TConstArrayView<UPackage*> LoadedPackages;
    int32 RecursiveDepth;
    bool bSynchronous;
};
 
enum class ECompiledInUObjectsRegisteredStatus
{
 
    // Registration for the given module has been delayed and will be registered with a layer notification where the package name is NAME_None.
    // Calls to FindObject<> for any delayed registrations will return nullptr.
    Delayed,
 
    // All pending registrations have been done but CDOs have not been created.  This may be invoked multiple times for the same package name.
    // Calls to FindObject<> for all pending registrations will return the UObject in question.
    PreCDO,
 
    // All pending registrations and CDO creation has been done.  Calls to FindObject<> for all pending registrations will return the UObject 
    // in question.  The CDO will also be available for any registered UClasses.
    PostCDO,
};
 
struct FCoreUObjectDelegates
{
#if WITH_EDITOR
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnObjectPropertyChanged, UObject*, struct FPropertyChangedEvent&);
    static COREUOBJECT_API FOnObjectPropertyChanged OnObjectPropertyChanged;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPreObjectPropertyChanged, UObject*, const class FEditPropertyChain&);
    static COREUOBJECT_API FOnPreObjectPropertyChanged OnPreObjectPropertyChanged;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPostObjectPropertyChanged, UObject*, const struct FPropertyChangedChainEvent&);
    static COREUOBJECT_API FOnPostObjectPropertyChanged OnPostObjectPropertyChanged;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnObjectModified, UObject*);
    static COREUOBJECT_API FOnObjectModified OnObjectModified;
 
    static COREUOBJECT_API TSet<UObject*> ObjectsModifiedThisFrame;
 
    static void BroadcastOnObjectModified(UObject* Object)
    {
        if (OnObjectModified.IsBound() && !ObjectsModifiedThisFrame.Contains(Object))
        {
            ObjectsModifiedThisFrame.Add(Object);
            OnObjectModified.Broadcast(Object);
        }
    }
 
    DECLARE_TS_MULTICAST_DELEGATE_ThreeParams(FOnObjectRenamed, UObject*, UObject*, FName);
    static COREUOBJECT_API FOnObjectRenamed OnObjectRenamed;
 
    static void BroadcastOnObjectRenamed(UObject* Object, UObject* OldOuter, FName OldName)
    {
        OnObjectRenamed.Broadcast(Object, OldOuter, OldName);
    }
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnObjectTransacted, UObject*, const class FTransactionObjectEvent&);
    static COREUOBJECT_API FOnObjectTransacted OnObjectTransacted;
 
    using FReplacementObjectMap = TMap<UObject*, UObject*>; // Alias for use in the macro
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnObjectsReplaced, const FReplacementObjectMap&);
    static COREUOBJECT_API FOnObjectsReplaced OnObjectsReplaced;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnObjectsReinstanced, const FReplacementObjectMap&);
    static COREUOBJECT_API FOnObjectsReinstanced OnObjectsReinstanced;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnVerseDeadReferences, const TSet<UClass*>& /*DeadClasses*/, const TSet<UObject*>& /*ActiveInstances*/, const TSet<UObject*>& /*TemplateInstances*/);
    static COREUOBJECT_API FOnVerseDeadReferences OnVerseDeadObjectReferences;
 
    DECLARE_TS_MULTICAST_DELEGATE_TwoParams(FOnObjectPostCDOCompiled, UObject*, const FObjectPostCDOCompiledContext&);
    static COREUOBJECT_API FOnObjectPostCDOCompiled OnObjectPostCDOCompiled;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnObjectPreSave, UObject*, FObjectPreSaveContext);
    static COREUOBJECT_API FOnObjectPreSave OnObjectPreSave;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnAssetLoaded, UObject*);
    static COREUOBJECT_API FOnAssetLoaded OnAssetLoaded;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam(FOnObjectConstructed, UObject*);
    static COREUOBJECT_API FOnObjectConstructed OnObjectConstructed;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnEndLoadPackage, const FEndLoadPackageContext&);
    static COREUOBJECT_API FOnEndLoadPackage OnEndLoadPackage;
#endif // WITH_EDITOR
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnPostInitSparseClassData, UClass*, UScriptStruct*, void*);
    static COREUOBJECT_API FOnPostInitSparseClassData OnPostInitSparseClassData;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnPackageReloaded, EPackageReloadPhase, FPackageReloadedEvent*);
    static COREUOBJECT_API FOnPackageReloaded OnPackageReloaded;
 
    DECLARE_DELEGATE_OneParam(FNetworkFileRequestPackageReload, const TArray<FString>& /*PackageNames*/);
    static COREUOBJECT_API FNetworkFileRequestPackageReload NetworkFileRequestPackageReload;
 
    DECLARE_DELEGATE_RetVal_ThreeParams(bool, FIsPackageOKToSaveDelegate, UPackage*, const FString&, FOutputDevice*);
    static COREUOBJECT_API FIsPackageOKToSaveDelegate IsPackageOKToSaveDelegate;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FReloadAddedClassesDelegate, const TArray<UClass*>&);
    static COREUOBJECT_API FReloadAddedClassesDelegate ReloadAddedClassesDelegate;
 
    DECLARE_MULTICAST_DELEGATE(FReloadReinstancingCompleteDelegate);
    static COREUOBJECT_API FReloadReinstancingCompleteDelegate ReloadReinstancingCompleteDelegate;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FReloadCompleteDelegate, EReloadCompleteReason);
    static COREUOBJECT_API FReloadCompleteDelegate ReloadCompleteDelegate;
 
    UE_DEPRECATED(all, "RegisterClassForHotReloadReinstancingDelegate is for internal use only.")
    static COREUOBJECT_API TMulticastDelegate<void(UClass* OldClass, UClass* NewClass, EHotReloadedClassFlags Flags)> RegisterClassForHotReloadReinstancingDelegate;
 
    UE_DEPRECATED(all, "ReinstanceHotReloadedClassesDelegate is for internal use only")
    static COREUOBJECT_API TMulticastDelegate<void()> ReinstanceHotReloadedClassesDelegate;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FCompiledInUObjectsRegisteredDelegate, FName /*Package*/, ECompiledInUObjectsRegisteredStatus Status);
    static COREUOBJECT_API FCompiledInUObjectsRegisteredDelegate CompiledInUObjectsRegisteredDelegate;
 
    /* Multicast delegate that is executed when any UObjects in packages need destroying before modules are unloaded. */
    DECLARE_MULTICAST_DELEGATE_OneParam(FCompiledInUObjectsRemovedDelegate, TConstArrayView<UPackage*>);
    static COREUOBJECT_API FCompiledInUObjectsRemovedDelegate CompiledInUObjectsRemovedDelegate;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FPreLoadMapDelegate, const FString& /* MapName */);
    static COREUOBJECT_API FPreLoadMapDelegate PreLoadMap;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FPreLoadMapWithContextDelegate, const FWorldContext& /*WorldContext*/, const FString& /* MapName */);
    static COREUOBJECT_API FPreLoadMapWithContextDelegate PreLoadMapWithContext;
    
    DECLARE_MULTICAST_DELEGATE_OneParam(FPostLoadMapDelegate, UWorld* /* LoadedWorld */);
    static COREUOBJECT_API FPostLoadMapDelegate PostLoadMapWithWorld;
 
    static COREUOBJECT_API FSimpleMulticastDelegate PostDemoPlay;
 
    static COREUOBJECT_API FSimpleMulticastDelegate& GetPreGarbageCollectDelegate();
 
    static COREUOBJECT_API FSimpleMulticastDelegate& GetGarbageCollectStartedDelegate();
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FTraceExternalRootsForReachabilityAnalysisDelegate, FGarbageCollectionTracer&, EObjectFlags, bool);
 
    static COREUOBJECT_API FSimpleMulticastDelegate PostReachabilityAnalysis;
 
    static COREUOBJECT_API FSimpleMulticastDelegate& GetPostGarbageCollect();
 
    static COREUOBJECT_API FSimpleMulticastDelegate& GetPostPurgeGarbageDelegate();
 
#if !UE_BUILD_SHIPPING
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnReportGarbageReferencers, TConstArrayView<struct FGarbageReferenceInfo>);
    static COREUOBJECT_API FOnReportGarbageReferencers& GetGarbageCollectReportGarbageReferencers();
#endif
 
    static COREUOBJECT_API FSimpleMulticastDelegate PreGarbageCollectConditionalBeginDestroy;
 
    static COREUOBJECT_API FSimpleMulticastDelegate PostGarbageCollectConditionalBeginDestroy;
 
    static COREUOBJECT_API FSimpleMulticastDelegate GarbageCollectComplete;
 
    DECLARE_DELEGATE_RetVal_OneParam(bool, FOnLoadObjectsOnTop, const FString&);
    static COREUOBJECT_API FOnLoadObjectsOnTop ShouldLoadOnTop;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FPackageCreatedForLoad, class UPackage*);
    static COREUOBJECT_API FPackageCreatedForLoad PackageCreatedForLoad;
 
    DECLARE_DELEGATE_RetVal_OneParam(FPrimaryAssetId, FGetPrimaryAssetIdForObject, const UObject*);
    static COREUOBJECT_API FGetPrimaryAssetIdForObject GetPrimaryAssetIdForObject;
 
    DECLARE_DELEGATE_RetVal_TwoParams(bool, FShouldCookPackageForPlatform, const UPackage*, const ITargetPlatform*);
    static COREUOBJECT_API FShouldCookPackageForPlatform ShouldCookPackageForPlatform;
};
 
extern COREUOBJECT_API bool GShouldVerifyGCAssumptions;
 
extern COREUOBJECT_API int32 GCreateGCClusters;
 
extern COREUOBJECT_API int32 GAssetClustreringEnabled;
 
COREUOBJECT_API UScriptStruct* GetFallbackStruct();
 
COREUOBJECT_API bool GetAllowNativeComponentClassOverrides();
 
namespace UE
{
 
class FAssetLog
{
public:
    inline explicit FAssetLog(const TCHAR* InPath UE_LIFETIMEBOUND) : Path(InPath) {}
    inline explicit FAssetLog(const FPackagePath& InPath UE_LIFETIMEBOUND) : PackagePath(&InPath) {}
    inline explicit FAssetLog(const UObject* InObject UE_LIFETIMEBOUND) : Object(InObject) {}
 
    friend void SerializeForLog(FCbWriter& Writer, const FAssetLog& AssetLog) { AssetLog.SerializeForLog(Writer); }
 
private:
    COREUOBJECT_API void SerializeForLog(FCbWriter& Writer) const;
    const TCHAR* Path = nullptr;
    const FPackagePath* PackagePath = nullptr;
    const UObject* Object = nullptr;
};
 
} // UE
 
namespace UE::Core::Private
{
COREUOBJECT_API void RecordAssetLog(
    const FName& CategoryName,
    ELogVerbosity::Type Verbosity,
    const FAssetLog& AssetLog,
    const FString& Message,
    const ANSICHAR* File,
    int32 Line);
} // UE::Core::Private
 
struct FAssetMsg
{
    static COREUOBJECT_API FString FormatPathForAssetLog(const TCHAR* Path);
 
    static COREUOBJECT_API FString FormatPathForAssetLog(const FPackagePath& Path);
 
    static COREUOBJECT_API FString FormatPathForAssetLog(const UObject* Object);
 
    static COREUOBJECT_API FString GetAssetLogString(const TCHAR* Path, const FString& Message);
    static COREUOBJECT_API FString GetAssetLogString(const FPackagePath& Path, const FString& Message);
    static COREUOBJECT_API FString GetAssetLogString(const UObject* Object, const FString& Message);
};
 
#define ASSET_LOG_FORMAT_STRING_ANSI "[AssetLog] %s: "
#define ASSET_LOG_FORMAT_STRING TEXT(ASSET_LOG_FORMAT_STRING_ANSI)
 
#if NO_LOGGING
    #define UE_ASSET_LOG(...)
#else
    #define UE_ASSET_LOG(CategoryName, Verbosity, Asset, Format, ...) \
    { \
        static_assert(TIsArrayOrRefOfTypeByPredicate<decltype(Format), TIsCharEncodingCompatibleWithTCHAR>::Value, "Formatting string must be a TCHAR array."); \
        static_assert((ELogVerbosity::Verbosity & ELogVerbosity::VerbosityMask) < ELogVerbosity::NumVerbosity && ELogVerbosity::Verbosity > 0, "Verbosity must be constant and in range."); \
        CA_CONSTANT_IF((ELogVerbosity::Verbosity & ELogVerbosity::VerbosityMask) <= ELogVerbosity::COMPILED_IN_MINIMUM_VERBOSITY && (ELogVerbosity::Warning & ELogVerbosity::VerbosityMask) <= FLogCategory##CategoryName::CompileTimeVerbosity) \
        { \
            UE_LOG_EXPAND_IS_FATAL(Verbosity, PREPROCESSOR_NOTHING, if (!CategoryName.IsSuppressed(ELogVerbosity::Verbosity))) \
            { \
                ::UE::Core::Private::RecordAssetLog(CategoryName.GetCategoryName(), ELogVerbosity::Verbosity, ::UE::FAssetLog(Asset), FString::Printf(Format, ##__VA_ARGS__), __FILE__, __LINE__); \
                UE_LOG_EXPAND_IS_FATAL(Verbosity, \
                    { \
                        UE_DEBUG_BREAK_AND_PROMPT_FOR_REMOTE(); \
                        FDebug::AssertFailed("", __FILE__, __LINE__, TEXT("%s: %s"), *FAssetMsg::FormatPathForAssetLog(Asset), *FString::Printf(Format, ##__VA_ARGS__)); \
                        CA_ASSUME(false); \
                    }, \
                    PREPROCESSOR_NOTHING \
                ) \
            } \
        } \
    }
#endif // NO_LOGGING
 
#if WITH_EDITORONLY_DATA
namespace UE::SavePackageUtilities
{
enum class EEditorOnlyObjectResult
{
    Uninitialized,
    EditorOnly,
    NonEditorOnly,
};
}// namespace UE::SavePackageUtilities
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITOR
COREUOBJECT_API bool IsEditorOnlyObject(const UObject* InObject, bool bCheckRecursive = true);
COREUOBJECT_API bool IsEditorOnlyObject(const UObject* InObject, bool bCheckRecursive,
    TFunctionRef<UE::SavePackageUtilities::EEditorOnlyObjectResult(const UObject* Object)> LookupInCache,
    TFunctionRef<void(const UObject* Object, bool bEditorOnly)> AddToCache);
 
#endif //WITH_EDITOR
 
class FFieldClass;
struct FClassFunctionLinkInfo;
struct FCppClassTypeInfoStatic;
 
typedef void (*SetterFuncPtr)(void* InContainer, const void* InValue);
typedef void (*GetterFuncPtr)(const void* InContainer, void* OutValue);
 
namespace UECodeGen_Private
{
    enum class EPropertyGenFlags : uint8
    {
        None              = 0x00,
 
        // First 6 bits are the property type
        Byte              = 0x00,
        Int8              = 0x01,
        Int16             = 0x02,
        Int               = 0x03,
        Int64             = 0x04,
        UInt16            = 0x05,
        UInt32            = 0x06,
        UInt64            = 0x07,
        //                = 0x08,
        //                = 0x09,
        Float             = 0x0A,
        Double            = 0x0B,
        Bool              = 0x0C,
        SoftClass         = 0x0D,
        WeakObject        = 0x0E,
        LazyObject        = 0x0F,
        SoftObject        = 0x10,
        Class             = 0x11,
        Object            = 0x12,
        Interface         = 0x13,
        Name              = 0x14,
        Str               = 0x15,
        Array             = 0x16,
        Map               = 0x17,
        Set               = 0x18,
        Struct            = 0x19,
        Delegate          = 0x1A,
        InlineMulticastDelegate = 0x1B,
        SparseMulticastDelegate = 0x1C,
        Text              = 0x1D,
        Enum              = 0x1E,
        FieldPath         = 0x1F,
        LargeWorldCoordinatesReal = 0x20,
        Optional          = 0x21,
        VerseValue        = 0x22,
        Utf8Str           = 0x23,
        AnsiStr           = 0x24,
        VerseString       = 0x25,
        VerseCell         = 0x26,
        VerseType         = 0x27,
 
        // Property-specific flags
        NativeBool        = 0x40,
        ObjectPtr         = 0x40,
 
    };
 
    static_assert(std::is_same_v<int32,  int         >, "CoreUObject property system expects int32 to be an int");
    static_assert(std::is_same_v<uint32, unsigned int>, "CoreUObject property system expects uint32 to be an unsigned int");
 
    ENUM_CLASS_FLAGS(EPropertyGenFlags)
 
    // Value which masks out the type of combined EPropertyGenFlags.
    inline constexpr EPropertyGenFlags PropertyTypeMask = (EPropertyGenFlags)0x3F;
 
#if WITH_METADATA
    struct FMetaDataPairParam
    {
        const char* NameUTF8;
        const char* ValueUTF8;
    };
#endif
 
    struct FEnumeratorParam
    {
        const char*               NameUTF8;
        int64                     Value;
    };
 
    // This is not a base class but is just a common initial sequence of all of the F*PropertyParams types below.
    // We don't want to use actual inheritance because we want to construct aggregated compile-time tables of these things.
    struct FPropertyParamsBase
    {
        const char*    NameUTF8;
        const char*       RepNotifyFuncUTF8;
        EPropertyFlags    PropertyFlags;
        EPropertyGenFlags Flags;
        EObjectFlags   ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16         ArrayDim;
    };
 
    struct FPropertyParamsBaseWithoutOffset // : FPropertyParamsBase
    {
        const char* NameUTF8;
        const char* RepNotifyFuncUTF8;
        EPropertyFlags    PropertyFlags;
        EPropertyGenFlags Flags;
        EObjectFlags   ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16         ArrayDim;
    };
 
    struct FPropertyParamsBaseWithOffset // : FPropertyParamsBase
    {
        const char*    NameUTF8;
        const char*       RepNotifyFuncUTF8;
        EPropertyFlags    PropertyFlags;
        EPropertyGenFlags Flags;
        EObjectFlags   ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16         ArrayDim;
        uint16         Offset;
    };
 
    struct FGenericPropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*       RepNotifyFuncUTF8;
        EPropertyFlags    PropertyFlags;
        EPropertyGenFlags Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FBytePropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UEnum*         (*EnumFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FBoolPropertyParams // : FPropertyParamsBaseWithoutOffset
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           ElementSize;
        uint16           SizeOfOuter;
        void           (*SetBitFunc)(void* Obj);
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FObjectPropertyParamsWithoutClass // : FPropertyParamsBaseWithOffset
    {
        const char* NameUTF8;
        const char* RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FObjectPropertyParamsWithClass // : FPropertyParamsBaseWithOffset
    {
        const char* NameUTF8;
        const char* RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UClass*        (*ClassFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FObjectPropertyParams // : FObjectPropertyParamsWithClass
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UClass*        (*ClassFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FClassPropertyParams // : FObjectPropertyParams
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UClass*        (*ClassFunc)();
        UClass*        (*MetaClassFunc)();      
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FVerseClassPropertyParams // : FClassPropertyParams
    {
        const char* NameUTF8;
        const char* RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UClass* (*ClassFunc)();
        UClass* (*MetaClassFunc)();
        bool            bRequiresConcrete;
        bool            bRequiresCastable;
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam* MetaDataArray;
#endif
    };
 
    struct FSoftClassPropertyParams // : FObjectPropertyParamsWithoutClass
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UClass*        (*MetaClassFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FInterfacePropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UClass*        (*InterfaceClassFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FStructPropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UScriptStruct* (*ScriptStructFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FDelegatePropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UFunction*     (*SignatureFunctionFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FMulticastDelegatePropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UFunction*     (*SignatureFunctionFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FEnumPropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*        RepNotifyFuncUTF8;
        EPropertyFlags     PropertyFlags;
        EPropertyGenFlags  Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        UEnum*         (*EnumFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FFieldPathPropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*      NameUTF8;
        const char*        RepNotifyFuncUTF8;
        EPropertyFlags     PropertyFlags;
        EPropertyGenFlags  Flags;
        EObjectFlags     ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16           ArrayDim;
        uint16           Offset;
        FFieldClass*     (*PropertyClassFunc)();
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FArrayPropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*         NameUTF8;
        const char*         RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EPropertyGenFlags   Flags;
        EObjectFlags        ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16              ArrayDim;
        uint16              Offset;
        EArrayPropertyFlags ArrayFlags;
#if WITH_METADATA
        uint16                    NumMetaData;
        const FMetaDataPairParam* MetaDataArray;
#endif
    };
 
    struct FMapPropertyParams // : FPropertyParamsBaseWithOffset
    {
        const char*       NameUTF8;
        const char*       RepNotifyFuncUTF8;
        EPropertyFlags    PropertyFlags;
        EPropertyGenFlags Flags;
        EObjectFlags      ObjectFlags;
        SetterFuncPtr  SetterFunc;
        GetterFuncPtr  GetterFunc;
        uint16            ArrayDim;
        uint16            Offset;
        EMapPropertyFlags MapFlags;
#if WITH_METADATA
        uint16                    NumMetaData;
        const FMetaDataPairParam* MetaDataArray;
#endif
    };
 
    // These property types don't add new any construction parameters to their base property
    typedef FGenericPropertyParams FInt8PropertyParams;
    typedef FGenericPropertyParams FInt16PropertyParams;
    typedef FGenericPropertyParams FIntPropertyParams;
    typedef FGenericPropertyParams FInt64PropertyParams;
    typedef FGenericPropertyParams FUInt16PropertyParams;
    typedef FGenericPropertyParams FUInt32PropertyParams;
    typedef FGenericPropertyParams FUInt64PropertyParams;
    typedef FGenericPropertyParams FFloatPropertyParams;
    typedef FGenericPropertyParams FDoublePropertyParams;
    typedef FGenericPropertyParams FLargeWorldCoordinatesRealPropertyParams;
    typedef FGenericPropertyParams FNamePropertyParams;
    typedef FGenericPropertyParams FStrPropertyParams;
    typedef FGenericPropertyParams FSetPropertyParams;
    typedef FGenericPropertyParams FTextPropertyParams;
    typedef FObjectPropertyParams  FWeakObjectPropertyParams;
    typedef FObjectPropertyParams  FLazyObjectPropertyParams;
    typedef FObjectPropertyParams  FObjectPtrPropertyParams;
    typedef FClassPropertyParams   FClassPtrPropertyParams;
    typedef FObjectPropertyParams  FSoftObjectPropertyParams;
    typedef FGenericPropertyParams FVerseValuePropertyParams;
    typedef FGenericPropertyParams FUtf8StrPropertyParams;
    typedef FGenericPropertyParams FAnsiStrPropertyParams;
    typedef FGenericPropertyParams FVerseStringPropertyParams;
 
    struct FFunctionBaseParams
    {
        UObject*                          (*OuterFunc)();
        UFunction*                        (*SuperFunc)();
        const char*                         NameUTF8;
        const FPropertyParamsBase* const*   PropertyArray;
        uint16                              NumProperties;
        uint16                              StructureSize;
        EObjectFlags                        ObjectFlags;
        EFunctionFlags                      FunctionFlags;
        uint16                              RPCId;
        uint16                              RPCResponseId;
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FFunctionParams : FFunctionBaseParams
    {
    };
 
    struct FDelegateFunctionParams : FFunctionBaseParams
    {
    };
 
    struct FSparseDelegateFunctionParams : FFunctionBaseParams
    {
        const char*                         OwningClassName;
        const char*                         DelegateName;
    };
 
    struct FVerseFunctionParams : FFunctionBaseParams
    {
        const char*                         AlternateName;
    };
 
    struct FEnumParams
    {
        UObject*                  (*OuterFunc)();
        FText                     (*DisplayNameFunc)(int32);
        const char*                 NameUTF8;
        const char*                 CppTypeUTF8;
        const FEnumeratorParam*     EnumeratorParams;
        EObjectFlags                ObjectFlags;
        int16                       NumEnumerators;
        EEnumFlags                  EnumFlags;
        uint8                       CppForm; // this is of type UEnum::ECppForm
#if WITH_METADATA
        uint16                      NumMetaData;
        const FMetaDataPairParam*   MetaDataArray;
#endif
    };
 
    struct FVerseEnumParams : FEnumParams
    {
        const char*                 QaulifiedName;
    };
 
    struct FStructParams
    {
        UObject*                          (*OuterFunc)();
        UScriptStruct*                    (*SuperFunc)();
        void*                             (*StructOpsFunc)(); // really returns UScriptStruct::ICppStructOps*
        const char*                         NameUTF8;
        const FPropertyParamsBase* const*   PropertyArray;
        uint16                              NumProperties;
        uint16                              SizeOf;
        uint8                               AlignOf;
        EObjectFlags                        ObjectFlags;
        uint32                              StructFlags; // EStructFlags
#if WITH_METADATA
        uint16                              NumMetaData;
        const FMetaDataPairParam*           MetaDataArray;
#endif
    };
 
    struct FVerseStructParams : FStructParams
    {
        const char*                         QaulifiedName;
    };
 
    struct FPackageParams
    {
        const char*                        NameUTF8;
        UObject*                  (*const *SingletonFuncArray)();
        int32                              NumSingletons;
        uint32                             PackageFlags; // EPackageFlags
        uint32                             BodyCRC;
        uint32                             DeclarationsCRC;
#if WITH_METADATA
        uint16                             NumMetaData;
        const FMetaDataPairParam*          MetaDataArray;
#endif
    };
 
    struct FImplementedInterfaceParams
    {
        UClass* (*ClassFunc)();
        int32     Offset;
        bool      bImplementedByK2;
        bool      bDirectInterface = false; // Used by verse
    };
 
    struct FClassParams
    {
        UClass*                                   (*ClassNoRegisterFunc)();
        const char*                                 ClassConfigNameUTF8;
        const FCppClassTypeInfoStatic*              CppClassInfo;
        UObject*                           (*const *DependencySingletonFuncArray)();
        const FClassFunctionLinkInfo*               FunctionLinkArray;
        const FPropertyParamsBase* const*           PropertyArray;
        const FImplementedInterfaceParams*          ImplementedInterfaceArray;
        uint32                                      NumDependencySingletons : 4;
        uint32                                      NumFunctions : 11;
        uint32                                      NumProperties : 11;
        uint32                                      NumImplementedInterfaces : 6;
        uint32                                      ClassFlags; // EClassFlags
#if WITH_METADATA
        uint16                                      NumMetaData;
        const FMetaDataPairParam*                   MetaDataArray;
#endif
    };
 
    struct FVerseClassParams : FClassParams
    {
        const char*                                 PackageRelativeVersePath;
        const char*                                 MangledPackageVersePath;
        uint32                                      VerseClassFlags;
    };
 
    COREUOBJECT_API void ConstructUFunction(UFunction** SingletonPtr, const FFunctionParams& Params);
    COREUOBJECT_API void ConstructUDelegateFunction(UFunction** SingletonPtr, const FDelegateFunctionParams& Params);
    COREUOBJECT_API void ConstructUSparseDelegateFunction(UFunction** SingletonPtr, const FSparseDelegateFunctionParams& Params);
    COREUOBJECT_API void ConstructUEnum(UEnum*& OutEnum, const FEnumParams& Params);
    COREUOBJECT_API void ConstructUScriptStruct(UScriptStruct*& OutStruct, const FStructParams& Params);
    COREUOBJECT_API void ConstructUPackage(UPackage*& OutPackage, const FPackageParams& Params);
    COREUOBJECT_API void ConstructUClass(UClass*& OutClass, const FClassParams& Params);
}
 
// METADATA_PARAMS(x, y) expands to x, y, if WITH_METADATA is set, otherwise expands to nothing
#if WITH_METADATA
    #define METADATA_PARAMS(x, y) x, y,
#else
    #define METADATA_PARAMS(x, y)
#endif
 
// IF_WITH_METADATA expands to its contents if WITH_METADATA is set, otherwise expands to nothing
#if WITH_METADATA
    #define IF_WITH_METADATA(...) __VA_ARGS__
#else
    #define IF_WITH_METADATA(...)
#endif
 
// IF_WITH_EDITOR(x, y) expands to x if WITH_EDITOR is set, otherwise expands to y
#if WITH_EDITOR
    #define IF_WITH_EDITOR(x, y) x
#else
    #define IF_WITH_EDITOR(x, y) y
#endif
 
// IF_WITH_EDITORONLY_DATA(x, y) expands to x if WITH_EDITORONLY_DATA is set, otherwise expands to y
#if WITH_EDITORONLY_DATA
    #define IF_WITH_EDITORONLY_DATA(x, y) x
#else
    #define IF_WITH_EDITORONLY_DATA(x, y) y
#endif
 
// IF_WITH_VERSE_VM(x, y) expands to x if WITH_VERSE_VM is set, otherwise expands to y
#if WITH_VERSE_VM
    #define IF_WITH_VERSE_VM(x, y) x
#else
    #define IF_WITH_VERSE_VM(x, y) y
#endif
 
enum class EDataValidationResult : uint8
{
    Invalid,
    Valid,
    NotValidated
};
 
COREUOBJECT_API EDataValidationResult CombineDataValidationResults(EDataValidationResult Result1, EDataValidationResult Result2);
 
// Types used by both constinit and non-constinit UHT codegen
namespace UE::CodeGen
{
    struct FClassNativeFunction
    {
        const UTF8CHAR* NameUTF8;
        void (*Pointer)(UObject* Context, FFrame& TheStack, RESULT_DECL);
    };
}
 
#if UE_WITH_CONSTINIT_UOBJECT
class FStructBaseChain;
struct ICppStructOps;
struct FVerseCallableThunk;
 
namespace UE::CodeGen::ConstInit
{
#if WITH_METADATA
    struct FMetaData
    {
        const UTF8CHAR* NameUTF8;
        const UTF8CHAR* ValueUTF8;
    };
#endif
 
    // Parameter wrapper for FField* or UObject* which can be used as a parameter in a constexpr context
    struct FFieldOwnerParam
    {
        union FValue
        {
            UObject* Object;
            FField* Field;
        } Value;
        bool bIsObject;
 
        constexpr FFieldOwnerParam()
        {
            Value.Object = nullptr;
            bIsObject = true;
        }
        // Implicit construction from UObject*
        constexpr FFieldOwnerParam(UObject* InObject)
        {
            Value.Object = InObject;
            bIsObject = true;
        }
        // Implicit construction from FField*
        constexpr FFieldOwnerParam(FField* InField)
        {
            Value.Field = InField;
            bIsObject = false;
        }
    };
 
    // Shared parameters for all properties for constant-initialization
    struct FPropertyParams
    {
        FFieldClass*        FieldClass;
        FFieldOwnerParam    Owner;
        FProperty*          NextProperty; // Next property in this exact struct, no link to inherited properties
        const UTF8CHAR* NameUTF8;
        const UTF8CHAR* RepNotifyFuncUTF8;
        EPropertyFlags      PropertyFlags;
        EObjectFlags        ObjectFlags;
        uint16              ArrayDim;
        uint16              Offset;
        int32               ElementSize;
#if WITH_METADATA
        TConstArrayView<FMetaData> MetaData;
#endif
 
        // Helper to initialize element size during delegating constructor call 
        consteval FPropertyParams& SetElementSize(int32 InSize)
        {
            ElementSize = InSize;
            return *this;
        }
    };
 
 
    // Param structures for initialization of constinit UObjects in generated code
    // Intended to be passed directly to consteval constructors as as aggregate initialization 
    // expressions using designated initializers and not stored in the binary as variables themselves
    struct FObjectParams    
    {
        EObjectFlags Flags      = RF_NoFlags;
        // UObject* rather than UClass* because consteval constructors must be inlined and TObjectPtr
        // cannot see inheritance hierarchy in definition of UObjectBase
        UObject* Class          = nullptr; 
        const UTF8CHAR* NameUTF8 = nullptr;
        UObject* Outer          = nullptr;
 
        consteval FObjectParams& SetClassIfUnset(UObject* InClass)
        { 
            Class = InClass;
            return *this;
        }
    };
 
    struct FPackageParams
    {
        FObjectParams Object;
        EPackageFlags Flags = PKG_None;
#if WITH_METADATA
        TConstArrayView<FMetaData> MetaData;
#endif
        uint32 BodiesHash = 0;
        uint32 DeclarationsHash = 0;
    };
 
    struct FUFieldParams
    {
        UField* Next;
    };
 
    struct FStructParams
    {
        UStruct* Super;
        UField* FirstChild;
        TArrayView<const FStructBaseChain*> BaseChain;
        FField* ChildProperties;
        int32 PropertiesSize;
        int16 MinAlignment;
#if WITH_METADATA
        TConstArrayView<FMetaData> MetaData;
#endif
    };
 
    struct FClassImplementedInterface
    {
        UClass* Class;
        int32 PointerOffset;
        bool bImplementedByK2;
        bool bVerseDirectInterface;
    };
 
    struct FClassParams
    {
        const TCHAR* ConfigName;
        void (*ClassConstructor)(const FObjectInitializer&);
        UObject* (*ClassVTableHelperCtorCaller)(FVTableHelper& Helper);
        FUObjectCppClassStaticFunctions CppClassStaticFunctions;
        EClassFlags ClassFlags;
        EClassCastFlags ClassCastFlags;
        const FCppClassTypeInfoStatic* CppClassTypeInfo;
        TConstArrayView<FClassNativeFunction> NativeFunctions;
        UClass* ClassWithin;
        TConstArrayView<FClassImplementedInterface> Interfaces;
        UScriptStruct* SparseClassDataStruct;
    };
 
    struct FVerseClassParams
    {
        const UTF8CHAR* PackageRelativeVersePath;
        const UTF8CHAR* MangledPackageVersePath;
#if WITH_VERSE_VM
        TConstArrayView<FVerseCallableThunk> VerseCallableThunks;
#endif
    };
 
    struct FVerseStructParams
    {
        uint32 GuidA;
        uint32 GuidB;
        uint32 GuidC;
        uint32 GuidD;
        const UTF8CHAR* QualifiedName;
    };
 
    struct FEnumParams
    {
        const UTF8CHAR* CppTypeStaticUTF8;
        TConstArrayView<const UTF8CHAR*> StaticNamesUTF8;
        TArrayView<int64> EnumValues;
        uint8 CppForm;
        EEnumFlags EnumFlags;
        FText (*DisplayNameFn)(int32);
#if WITH_METADATA
        TConstArrayView<FMetaData> MetaData;
#endif
    };
 
    struct FVerseEnumParams
    {
        const UTF8CHAR* QualifiedName;
    };
 
    struct FFunctionParams
    {
        void (*NativeFunction)(UObject* Context, FFrame& TheStack, RESULT_DECL);
        EFunctionFlags FunctionFlags;
        int16 RPCId;
        int16 RPCResponseId;
    };
 
    struct FVerseFunctionParams
    {
        const UTF8CHAR* AlternateNameUTF8;
    };
 
    struct FSparseDelegateParams
    {
        const UTF8CHAR* SparseOwningClassNameUTF8;
        const UTF8CHAR* SparseDelegateNameUTF8;
    };
}
#endif // UE_WITH_CONSTINIT_UOBJECT