ObjectMacros.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ObjectMacros.h: Helper macros and defines for UObject system
=============================================================================*/
 
#pragma once
 
// IWYU pragma: begin_keep
#include "Misc/EnumClassFlags.h"
#include "UObject/Script.h"
// IWYU pragma: end_keep
 
class FObjectInitializer;
class FReferenceCollector;
struct FAppendToClassSchemaContext;
struct FFrame;
struct FClassReloadVersionInfo;
struct FTopLevelAssetPath;
 
typedef uint64 ScriptPointerType;
 
#if PLATFORM_VTABLE_AT_END_OF_CLASS
#error "not supported in UE"
#endif
 
#ifndef USE_COMPILED_IN_NATIVES
#define USE_COMPILED_IN_NATIVES 1
#endif
 
#define THREADSAFE_UOBJECTS 1
 
// Enumeration of different methods of determining ustruct relationships.
#define USTRUCT_ISCHILDOF_OUTERWALK  1 // walks the super struct chain                                     - original IsA behavior
#define USTRUCT_ISCHILDOF_STRUCTARRAY 2 // stores an array of parents per struct and uses this to compare - faster than 1 and thread-safe but can have issues with BP reinstancing and hot reload
 
// USTRUCT_FAST_ISCHILDOF_IMPL sets which implementation of IsChildOf to use.
#if WITH_EDITOR
    // On editor, we use the outerwalk implementation because BP reinstancing and hot reload
    // mess up the struct array
    #define USTRUCT_FAST_ISCHILDOF_IMPL USTRUCT_ISCHILDOF_OUTERWALK
#else
    #define USTRUCT_FAST_ISCHILDOF_IMPL USTRUCT_ISCHILDOF_STRUCTARRAY
#endif
 
// USTRUCT_FAST_ISCHILDOF_COMPARE_WITH_OUTERWALK, if set, does a checked comparison of the current implementation against the outer walk - used for testing.
#define USTRUCT_FAST_ISCHILDOF_COMPARE_WITH_OUTERWALK 0
 
// Allow UObject reflection info to be initialized in the binary at compile time instead of allocated on the heap at runtime.
#ifndef UE_WITH_CONSTINIT_UOBJECT
    #define UE_WITH_CONSTINIT_UOBJECT 0
#endif
 
// Allows relaxing uobject constinit declarations to be ordinary globals with dynamic initialization allowed
#ifndef UE_CONSTINIT_UOBJECT_DECL
    #define UE_CONSTINIT_UOBJECT_DECL constinit
#endif
 
 
/*-----------------------------------------------------------------------------
    Core enumerations.
-----------------------------------------------------------------------------*/
 
enum ELoadFlags
{
    LOAD_None                       = 0x00000000,   
    LOAD_Async                      = 0x00000001,   
    LOAD_NoWarn                     = 0x00000002,   
    LOAD_EditorOnly                 = 0x00000004,   
    LOAD_ResolvingDeferredExports   = 0x00000008,   
    LOAD_Verify                     = 0x00000010,   
//  LOAD_Unused                     = 0x00000020,   ///< Allow plain DLLs.
//  LOAD_Unused                     = 0x00000040
    LOAD_NoVerify                   = 0x00000080,   
    LOAD_IsVerifying                = 0x00000100,   
    LOAD_SkipLoadImportedPackages   = 0x00000200,   
    LOAD_RegenerateBulkDataGuids UE_DEPRECATED(5.5, "This flag is now obsolete as the functionality is unnecessary.") = 0x00000400, 
//  LOAD_Unused                     = 0x00000800,
    LOAD_DisableDependencyPreloading = 0x00001000,  
    LOAD_Quiet                      = 0x00002000,   
    LOAD_FindIfFail                 = 0x00004000,   
    LOAD_MemoryReader               = 0x00008000,   
    LOAD_NoRedirects                = 0x00010000,   
    LOAD_ForDiff                    = 0x00020000,   
    LOAD_PackageForPIE              = 0x00080000,   
    LOAD_DeferDependencyLoads       = 0x00100000,   
    LOAD_ForFileDiff                = 0x00200000,   
    LOAD_DisableCompileOnLoad       = 0x00400000,   
    LOAD_DisableEngineVersionChecks = 0x00800000,   
};
 
enum ESaveFlags
{
    SAVE_None                       = 0x00000000,   
    SAVE_NoError                    = 0x00000001,   
    SAVE_FromAutosave               = 0x00000002,   
    SAVE_KeepDirty                  = 0x00000004,   
    SAVE_KeepGUID UE_DEPRECATED(5.6, "KeepPackageGUIDOnSave is no longer supported, because package save no longer records arbitrary guids but instead records a hash of the package's bytes - PackageSavedHash.") = 0x00000008,
    SAVE_Async                      = 0x00000010,   
    SAVE_Unversioned_Native         = 0x00000020,   
    SAVE_CutdownPackage             = 0x00000040,   
    SAVE_KeepEditorOnlyCookedPackages = 0x00000080,  
    SAVE_Concurrent                 = 0x00000100,   
//  SAVE_Unused                     = 0x00000200,
//  SAVE_Unused                     = 0x00000400,
//  SAVE_Unused                     = 0x00000800,
    SAVE_CompareLinker UE_DEPRECATED(5.6, "Comparing Linkers is no longer used. Contact Epic if you need this functionality.") = 0x00001000,
    SAVE_BulkDataByReference        = 0x00002000,   
    SAVE_Unversioned_Properties     = 0x00004000,   
    SAVE_Optional                   = 0x00008000,   
    SAVE_AllowTimeout               = 0x00010000,   
    SAVE_RehydratePayloads          = 0x00020000,   
    SAVE_CookSoftPackageReferences  = 0x00040000,   
    SAVE_Unversioned = SAVE_Unversioned_Native | SAVE_Unversioned_Properties,
};
 
enum EPackageFlags
{
    PKG_None                        = 0x00000000,   
    PKG_NewlyCreated                = 0x00000001,   
    PKG_ClientOptional              = 0x00000002,   
    PKG_ServerSideOnly              = 0x00000004,   
    PKG_CompiledIn                  = 0x00000010,   
    PKG_ForDiffing                  = 0x00000020,   
    PKG_EditorOnly                  = 0x00000040,   
    PKG_Developer                   = 0x00000080,   
    PKG_UncookedOnly                = 0x00000100,   
    PKG_Cooked                      = 0x00000200,   
    PKG_ContainsNoAsset             = 0x00000400,   
    PKG_NotExternallyReferenceable  = 0x00000800,   
    PKG_AccessSpecifierEpicInternal = 0x00001000,   
    PKG_UnversionedProperties       = 0x00002000,   
    PKG_ContainsMapData             = 0x00004000,   
    PKG_IsSaving                    = 0x00008000,   
    PKG_Compiling                   = 0x00010000,   
    PKG_ContainsMap                 = 0x00020000,   
    PKG_RequiresLocalizationGather  = 0x00040000,   
    PKG_LoadUncooked                = 0x00080000,   
    PKG_PlayInEditor                = 0x00100000,   
    PKG_ContainsScript              = 0x00200000,   
    PKG_DisallowExport              = 0x00400000,   
//  PKG_Unused                      = 0x00800000,
//  PKG_Unused                      = 0x01000000,   
//  PKG_Unused                      = 0x02000000,   
//  PKG_Unused                      = 0x04000000,
    PKG_CookGenerated               = 0x08000000,   
    PKG_DynamicImports              = 0x10000000,   
    PKG_RuntimeGenerated            = 0x20000000,   
    PKG_ReloadingForCooker          = 0x40000000,   
    PKG_FilterEditorOnly            = 0x80000000,   
};
 
// Transient Flags are cleared when serializing to or from PackageFileSummary
#define PKG_TransientFlags  (PKG_NewlyCreated | PKG_IsSaving | PKG_ReloadingForCooker)
 
#define PKG_InMemoryOnly    (EPackageFlags)(PKG_CompiledIn | PKG_NewlyCreated)
 
ENUM_CLASS_FLAGS(EPackageFlags);
 
// Internal enums.
 
enum EStaticConstructor             {EC_StaticConstructor};
enum EInternal                      {EC_InternalUseOnlyConstructor};
enum ECppProperty                   {EC_CppProperty};
 
class FVTableHelper
{
public:
    FVTableHelper()
    {
        EnsureRetrievingVTablePtrDuringCtor(TEXT("FVTableHelper()"));
    }
};
 
#define NO_API
 
enum EClassFlags
{
    CLASS_None                = 0x00000000u,
    CLASS_Abstract            = 0x00000001u,
    CLASS_DefaultConfig       = 0x00000002u,
    CLASS_Config              = 0x00000004u,
    CLASS_Transient           = 0x00000008u,
    CLASS_Optional            = 0x00000010u,
    CLASS_MatchedSerializers  = 0x00000020u,
    CLASS_ProjectUserConfig   = 0x00000040u,
    CLASS_Native              = 0x00000080u,
 
    // CLASS_Unused           = 0x00000100u,
 
    CLASS_NotPlaceable        = 0x00000200u,
    CLASS_PerObjectConfig     = 0x00000400u,
    
    CLASS_ReplicationDataIsSetUp = 0x00000800u,
    
    CLASS_EditInlineNew       = 0x00001000u,
    CLASS_CollapseCategories  = 0x00002000u,
    CLASS_Interface           = 0x00004000u,
    CLASS_PerPlatformConfig   = 0x00008000u,
    CLASS_Const               = 0x00010000u,
 
    CLASS_NeedsDeferredDependencyLoading = 0x00020000u,
    
    CLASS_CompiledFromBlueprint  = 0x00040000u,
 
    CLASS_MinimalAPI          = 0x00080000u,
    
    CLASS_RequiredAPI         = 0x00100000u,
 
    CLASS_DefaultToInstanced  = 0x00200000u,
 
    CLASS_TokenStreamAssembled  = 0x00400000u,
    CLASS_HasInstancedReference= 0x00800000u,
    CLASS_Hidden              = 0x01000000u,
    CLASS_Deprecated          = 0x02000000u,
    CLASS_HideDropDown        = 0x04000000u,
    CLASS_GlobalUserConfig    = 0x08000000u,
    CLASS_Intrinsic           = 0x10000000u,
    CLASS_Constructed         = 0x20000000u,
    CLASS_ConfigDoNotCheckDefaults = 0x40000000u,
    CLASS_NewerVersionExists  = 0x80000000u,
};
 
// Declare bitwise operators to allow EClassFlags to be combined but still retain type safety
ENUM_CLASS_FLAGS(EClassFlags);
 
#define CLASS_Inherit ((EClassFlags)(CLASS_Transient | CLASS_Optional | CLASS_DefaultConfig | CLASS_Config | CLASS_PerObjectConfig | CLASS_ConfigDoNotCheckDefaults | CLASS_NotPlaceable \
                        | CLASS_Const | CLASS_HasInstancedReference | CLASS_Deprecated | CLASS_DefaultToInstanced | CLASS_GlobalUserConfig | CLASS_ProjectUserConfig | CLASS_PerPlatformConfig | CLASS_NeedsDeferredDependencyLoading))
 
#define CLASS_RecompilerClear ((EClassFlags)(CLASS_Inherit | CLASS_Abstract | CLASS_Native | CLASS_Intrinsic | CLASS_TokenStreamAssembled))
 
#define CLASS_ShouldNeverBeLoaded ((EClassFlags)(CLASS_Native | CLASS_Optional | CLASS_Intrinsic | CLASS_TokenStreamAssembled))
 
#define CLASS_ScriptInherit ((EClassFlags)(CLASS_Inherit | CLASS_EditInlineNew | CLASS_CollapseCategories))
 
#define CLASS_SaveInCompiledInClasses ((EClassFlags)(\
    CLASS_Abstract | \
    CLASS_DefaultConfig | \
    CLASS_GlobalUserConfig | \
    CLASS_ProjectUserConfig | \
    CLASS_PerPlatformConfig | \
    CLASS_Config | \
    CLASS_Transient | \
    CLASS_Optional | \
    CLASS_Native | \
    CLASS_NotPlaceable | \
    CLASS_PerObjectConfig | \
    CLASS_PerPlatformConfig | \
    CLASS_ConfigDoNotCheckDefaults | \
    CLASS_EditInlineNew | \
    CLASS_CollapseCategories | \
    CLASS_Interface | \
    CLASS_DefaultToInstanced | \
    CLASS_HasInstancedReference | \
    CLASS_Hidden | \
    CLASS_Deprecated | \
    CLASS_HideDropDown | \
    CLASS_Intrinsic | \
    CLASS_Const | \
    CLASS_MinimalAPI | \
    CLASS_RequiredAPI | \
    CLASS_MatchedSerializers | \
    CLASS_NeedsDeferredDependencyLoading))
 
#define CLASS_AllFlags ((EClassFlags)0xFFFFFFFFu)
 
 
enum EClassCastFlags : uint64
{
    CASTCLASS_None = 0x0000000000000000,
 
    CASTCLASS_UField                        = 0x0000000000000001,
    CASTCLASS_FInt8Property                 = 0x0000000000000002,
    CASTCLASS_UEnum                         = 0x0000000000000004,
    CASTCLASS_UStruct                       = 0x0000000000000008,
    CASTCLASS_UScriptStruct                 = 0x0000000000000010,
    CASTCLASS_UClass                        = 0x0000000000000020,
    CASTCLASS_FByteProperty                 = 0x0000000000000040,
    CASTCLASS_FIntProperty                  = 0x0000000000000080,
    CASTCLASS_FFloatProperty                = 0x0000000000000100,
    CASTCLASS_FUInt64Property               = 0x0000000000000200,
    CASTCLASS_FClassProperty                = 0x0000000000000400,
    CASTCLASS_FUInt32Property               = 0x0000000000000800,
    CASTCLASS_FInterfaceProperty            = 0x0000000000001000,
    CASTCLASS_FNameProperty                 = 0x0000000000002000,
    CASTCLASS_FStrProperty                  = 0x0000000000004000,
    CASTCLASS_FProperty                     = 0x0000000000008000,
    CASTCLASS_FObjectProperty               = 0x0000000000010000,
    CASTCLASS_FBoolProperty                 = 0x0000000000020000,
    CASTCLASS_FUInt16Property               = 0x0000000000040000,
    CASTCLASS_UFunction                     = 0x0000000000080000,
    CASTCLASS_FStructProperty               = 0x0000000000100000,
    CASTCLASS_FArrayProperty                = 0x0000000000200000,
    CASTCLASS_FInt64Property                = 0x0000000000400000,
    CASTCLASS_FDelegateProperty             = 0x0000000000800000,
    CASTCLASS_FNumericProperty              = 0x0000000001000000,
    CASTCLASS_FMulticastDelegateProperty    = 0x0000000002000000,
    CASTCLASS_FObjectPropertyBase           = 0x0000000004000000,
    CASTCLASS_FWeakObjectProperty           = 0x0000000008000000,
    CASTCLASS_FLazyObjectProperty           = 0x0000000010000000,
    CASTCLASS_FSoftObjectProperty           = 0x0000000020000000,
    CASTCLASS_FTextProperty                 = 0x0000000040000000,
    CASTCLASS_FInt16Property                = 0x0000000080000000,
    CASTCLASS_FDoubleProperty               = 0x0000000100000000,
    CASTCLASS_FSoftClassProperty            = 0x0000000200000000,
    CASTCLASS_UPackage                      = 0x0000000400000000,
    CASTCLASS_ULevel                        = 0x0000000800000000,
    CASTCLASS_AActor                        = 0x0000001000000000,
    CASTCLASS_APlayerController             = 0x0000002000000000,
    CASTCLASS_APawn                         = 0x0000004000000000,
    CASTCLASS_USceneComponent               = 0x0000008000000000,
    CASTCLASS_UPrimitiveComponent           = 0x0000010000000000,
    CASTCLASS_USkinnedMeshComponent         = 0x0000020000000000,
    CASTCLASS_USkeletalMeshComponent        = 0x0000040000000000,
    CASTCLASS_UBlueprint                    = 0x0000080000000000,
    CASTCLASS_UDelegateFunction             = 0x0000100000000000,
    CASTCLASS_UStaticMeshComponent          = 0x0000200000000000,
    CASTCLASS_FMapProperty                  = 0x0000400000000000,
    CASTCLASS_FSetProperty                  = 0x0000800000000000,
    CASTCLASS_FEnumProperty                 = 0x0001000000000000,
    CASTCLASS_USparseDelegateFunction       = 0x0002000000000000,
    CASTCLASS_FMulticastInlineDelegateProperty  = 0x0004000000000000,
    CASTCLASS_FMulticastSparseDelegateProperty  = 0x0008000000000000,
    CASTCLASS_FFieldPathProperty            = 0x0010000000000000,
    //                                      = 0x0020000000000000,
    //                                      = 0x0040000000000000,
    CASTCLASS_FLargeWorldCoordinatesRealProperty = 0x0080000000000000,
    CASTCLASS_FOptionalProperty             = 0x0100000000000000,
    CASTCLASS_FVValueProperty               = 0x0200000000000000,
    CASTCLASS_FVRestValueProperty           = 0x0400000000000000,
    CASTCLASS_FVerseStringProperty          = 0x0800000000000000,
    CASTCLASS_FUtf8StrProperty              = 0x1000000000000000,
    CASTCLASS_FAnsiStrProperty              = 0x2000000000000000,
    CASTCLASS_FVCellProperty                = 0x4000000000000000,
    //                                      = 0x8000000000000000,
};
 
#define CASTCLASS_AllFlags ((EClassCastFlags)0xFFFFFFFFFFFFFFFF)
 
ENUM_CLASS_FLAGS(EClassCastFlags)
 
 
 
enum EPropertyFlags : uint64
{
    CPF_None = 0,
 
    CPF_Edit                            = 0x0000000000000001,   
    CPF_ConstParm                       = 0x0000000000000002,   
    CPF_BlueprintVisible                = 0x0000000000000004,   
    CPF_ExportObject                    = 0x0000000000000008,   
    CPF_BlueprintReadOnly               = 0x0000000000000010,   
    CPF_Net                             = 0x0000000000000020,   
    CPF_EditFixedSize                   = 0x0000000000000040,   
    CPF_Parm                            = 0x0000000000000080,   
    CPF_OutParm                         = 0x0000000000000100,   
    CPF_ZeroConstructor                 = 0x0000000000000200,   
    CPF_ReturnParm                      = 0x0000000000000400,   
    CPF_DisableEditOnTemplate           = 0x0000000000000800,   
    CPF_NonNullable                     = 0x0000000000001000,   
    CPF_Transient                       = 0x0000000000002000,   
    CPF_Config                          = 0x0000000000004000,   
    CPF_RequiredParm                    = 0x0000000000008000,   
    CPF_DisableEditOnInstance           = 0x0000000000010000,   
    CPF_EditConst                       = 0x0000000000020000,   
    CPF_GlobalConfig                    = 0x0000000000040000,   
    CPF_InstancedReference              = 0x0000000000080000,   
    CPF_ExperimentalExternalObjects     = 0x0000000000100000,   
    CPF_DuplicateTransient              = 0x0000000000200000,   
    //CPF_                              = 0x0000000000400000,   ///< 
    //CPF_                              = 0x0000000000800000,   ///< 
    CPF_SaveGame                        = 0x0000000001000000,   
    CPF_NoClear                         = 0x0000000002000000,   
    CPF_Virtual                         = 0x0000000004000000,   
    CPF_ReferenceParm                   = 0x0000000008000000,   
    CPF_BlueprintAssignable             = 0x0000000010000000,   
    CPF_Deprecated                      = 0x0000000020000000,   
    CPF_IsPlainOldData                  = 0x0000000040000000,   
    CPF_RepSkip                         = 0x0000000080000000,   
    CPF_RepNotify                       = 0x0000000100000000,   
    CPF_Interp                          = 0x0000000200000000,   
    CPF_NonTransactional                = 0x0000000400000000,   
    CPF_EditorOnly                      = 0x0000000800000000,   
    CPF_NoDestructor                    = 0x0000001000000000,   
    //CPF_                              = 0x0000002000000000,   ///<
    CPF_AutoWeak                        = 0x0000004000000000,   
    CPF_ContainsInstancedReference      = 0x0000008000000000,   
    CPF_AssetRegistrySearchable         = 0x0000010000000000,   
    CPF_SimpleDisplay                   = 0x0000020000000000,   
    CPF_AdvancedDisplay                 = 0x0000040000000000,   
    CPF_Protected                       = 0x0000080000000000,   
    CPF_BlueprintCallable               = 0x0000100000000000,   
    CPF_BlueprintAuthorityOnly          = 0x0000200000000000,   
    CPF_TextExportTransient             = 0x0000400000000000,   
    CPF_NonPIEDuplicateTransient        = 0x0000800000000000,   
    CPF_ExposeOnSpawn                   = 0x0001000000000000,   
    CPF_PersistentInstance              = 0x0002000000000000,   
    CPF_UObjectWrapper                  = 0x0004000000000000,   
    CPF_HasGetValueTypeHash             = 0x0008000000000000,   
    CPF_NativeAccessSpecifierPublic     = 0x0010000000000000,   
    CPF_NativeAccessSpecifierProtected  = 0x0020000000000000,   
    CPF_NativeAccessSpecifierPrivate    = 0x0040000000000000,   
    CPF_SkipSerialization               = 0x0080000000000000,   
    CPF_TObjectPtr                      = 0x0100000000000000,   
    CPF_ExperimentalOverridableLogic    = 0x0200000000000000,   
    CPF_ExperimentalAlwaysOverriden     = 0x0400000000000000,   
    CPF_ExperimentalNeverOverriden      = 0x0800000000000000,   
    CPF_AllowSelfReference              = 0x1000000000000000,   
};
 
#define CPF_NativeAccessSpecifiers  (CPF_NativeAccessSpecifierPublic | CPF_NativeAccessSpecifierProtected | CPF_NativeAccessSpecifierPrivate)
 
#define CPF_ParmFlags               (CPF_Parm | CPF_OutParm | CPF_ReturnParm | CPF_RequiredParm | CPF_ReferenceParm | CPF_ConstParm )
 
#define CPF_PropagateToArrayInner    (CPF_ExportObject | CPF_PersistentInstance | CPF_InstancedReference | CPF_ContainsInstancedReference | CPF_Config | CPF_EditConst | CPF_Deprecated | CPF_EditorOnly | CPF_AutoWeak | CPF_UObjectWrapper )
#define CPF_PropagateToOptionalInner (CPF_ExportObject | CPF_PersistentInstance | CPF_InstancedReference | CPF_ContainsInstancedReference | CPF_Config | CPF_EditConst | CPF_Deprecated | CPF_EditorOnly | CPF_AutoWeak | CPF_UObjectWrapper | CPF_Edit )
#define CPF_PropagateToMapValue      (CPF_ExportObject | CPF_PersistentInstance | CPF_InstancedReference | CPF_ContainsInstancedReference | CPF_Config | CPF_EditConst | CPF_Deprecated | CPF_EditorOnly | CPF_AutoWeak | CPF_UObjectWrapper | CPF_Edit )
#define CPF_PropagateToMapKey        (CPF_ExportObject | CPF_PersistentInstance | CPF_InstancedReference | CPF_ContainsInstancedReference | CPF_Config | CPF_EditConst | CPF_Deprecated | CPF_EditorOnly | CPF_AutoWeak | CPF_UObjectWrapper | CPF_Edit )
#define CPF_PropagateToSetElement    (CPF_ExportObject | CPF_PersistentInstance | CPF_InstancedReference | CPF_ContainsInstancedReference | CPF_Config | CPF_EditConst | CPF_Deprecated | CPF_EditorOnly | CPF_AutoWeak | CPF_UObjectWrapper | CPF_Edit )
 
#define CPF_InterfaceClearMask      (CPF_ExportObject|CPF_InstancedReference|CPF_ContainsInstancedReference)
 
#define CPF_DevelopmentAssets       (CPF_EditorOnly)
 
#define CPF_ComputedFlags           (CPF_IsPlainOldData | CPF_NoDestructor | CPF_ZeroConstructor | CPF_HasGetValueTypeHash)
 
#define CPF_TObjectPtrWrapper       (CPF_UObjectWrapper | CPF_TObjectPtr)
#define CPF_AllFlags                ((EPropertyFlags)0xFFFFFFFFFFFFFFFF)
 
ENUM_CLASS_FLAGS(EPropertyFlags)
 
 
enum class EArrayPropertyFlags : uint8
{
    None,
    UsesMemoryImageAllocator
};
 
ENUM_CLASS_FLAGS(EArrayPropertyFlags)
 
 
enum class EMapPropertyFlags : uint8
{
    None,
    UsesMemoryImageAllocator
};
 
ENUM_CLASS_FLAGS(EMapPropertyFlags)
 
enum class EPropertyObjectReferenceType : uint32
{
    None = 0,
    Strong = 1 << 0, // Hard reference to a UObject, keeps the object from being garbage collected
    Weak = 1 << 1,   // Weak reference to a UObject, does not keep the object from being garbage collected, does not become valid again after object is unloaded and reloaded.
    Soft = 1 << 2,   // Soft path/identity-based reference to a UObject, does not keep the object from being garbage collected, does become valid again after object is unloaded and reloaded.
    Conservative = 1 << 3,   // Not a real reference type, used to mark native struct serializers which may serialize unknown reference types and to conservatively populate RefLink with such struct properties.
    
    MAX = Conservative << 1, // Marker for iterating over all flags
    Any = Strong | Weak | Soft | Conservative,
};
ENUM_CLASS_FLAGS(EPropertyObjectReferenceType);
 
COREUOBJECT_API const TCHAR* LexToString(EPropertyObjectReferenceType Type);
 
enum EObjectFlags
{
    // Do not add new flags unless they truly belong here. There are alternatives.
    // if you change any the bit of any of the RF_Load flags, then you will need legacy serialization
    RF_NoFlags                  = 0x00000000,   
 
    // This first group of flags mostly has to do with what kind of object it is. Other than transient, these are the persistent object flags.
    // The garbage collector also tends to look at these.
    RF_Public                   =0x00000001,    
    RF_Standalone               =0x00000002,    
    RF_MarkAsNative             =0x00000004,    
    RF_Transactional            =0x00000008,    
    RF_ClassDefaultObject       =0x00000010,    
    RF_ArchetypeObject          =0x00000020,    
    RF_Transient                =0x00000040,    
 
    // This group of flags is primarily concerned with garbage collection.
    RF_MarkAsRootSet            =0x00000080,    
    RF_TagGarbageTemp           =0x00000100,    
 
    // The group of flags tracks the stages of the lifetime of a uobject
    RF_NeedInitialization       =0x00000200,    
    RF_NeedLoad                 =0x00000400,    
    RF_KeepForCooker UE_DEPRECATED(5.6, "This flag is now obsolete as the functionality is unnecessary.")           =0x00000800,    
    RF_NeedPostLoad             =0x00001000,    
    RF_NeedPostLoadSubobjects   =0x00002000,    
    RF_NewerVersionExists       =0x00004000,    
    RF_BeginDestroyed           =0x00008000,    
    RF_FinishDestroyed          =0x00010000,    
 
    // Misc. Flags
    RF_BeingRegenerated         =0x00020000,    
    RF_DefaultSubObject         =0x00040000,    
    RF_WasLoaded                =0x00080000,    
    RF_TextExportTransient      =0x00100000,    
    RF_LoadCompleted            =0x00200000,    
    RF_InheritableComponentTemplate = 0x00400000, 
    RF_DuplicateTransient       =0x00800000,    
    RF_StrongRefOnFrame         =0x01000000,    
    RF_NonPIEDuplicateTransient =0x02000000,    
    RF_ImmutableDefaultObject   =0x04000000,    
    RF_WillBeLoaded             =0x08000000,    
    RF_HasExternalPackage       =0x10000000,    
    RF_MigratingAsset           =0x20000000,    
 
    // RF_MirroredGarbage is mirrored in EInternalObjectFlags::Garbage because checking the internal flags is much faster for the Garbage Collector
    // while checking the object flags is much faster outside of it where the Object pointer is already available and most likely cached.
    RF_MirroredGarbage          =0x40000000,    
    RF_AllocatedInSharedPage    =0x80000000,    
};
 
UE_DEPRECATED(5.4, "RF_InternalPendingKill should no longer be used. Use IsValid(Object) instead.")
inline constexpr EObjectFlags RF_InternalPendingKill = RF_MirroredGarbage;
UE_DEPRECATED(5.4, "RF_InternalGarbage should no longer be used. Use IsValid(Object) instead.")
inline constexpr EObjectFlags RF_InternalGarbage = RF_MirroredGarbage;
UE_DEPRECATED(5.4, "RF_InternalMirroredFlags should no longer be used. Use IsValid(Object) instead.")
inline constexpr EObjectFlags RF_InternalMirroredFlags = RF_MirroredGarbage;
UE_DEPRECATED(5.5, "RF_HasPlaceholderType is no longer in use.")
inline constexpr EObjectFlags RF_HasPlaceholderType = EObjectFlags(0x20000000);
 
#define RF_AllFlags             (EObjectFlags)0xffffffff    
 
#define RF_Load                     ((EObjectFlags)(RF_Public | RF_Standalone | RF_Transactional | RF_ClassDefaultObject | RF_ArchetypeObject | RF_DefaultSubObject | RF_TextExportTransient | RF_InheritableComponentTemplate | RF_DuplicateTransient | RF_NonPIEDuplicateTransient | RF_MigratingAsset)) 
 
#define RF_PropagateToSubObjects    ((EObjectFlags)(RF_Public | RF_ArchetypeObject | RF_Transactional | RF_Transient))
 
ENUM_CLASS_FLAGS(EObjectFlags);
 
COREUOBJECT_API FString LexToString(EObjectFlags Flags);
 
enum class EInternalObjectFlags : int32
{
    None = 0,
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    Remote = 1 << 0, //< Object is no longer owned by this process
    RemoteReference = 1 << 1, //< Object referenced by remote process
    Borrowed = 1 << 2, //< Object that is not owned by this process 
#else
    Remote = 0,
    RemoteReference = 0,
    Borrowed = 0,
#endif
 
 
    // NOTE that the minimum flag bit index is currently 14 (unless compiling with UE_WITH_REMOTE_OBJECT_HANDLE). 
    // See EInternalObjectFlags_MinFlagBitIndex and UE_ENABLE_FUOBJECT_ITEM_PACKING in UObjectArray.h
 
    ReachabilityFlag0 = 1 << 14, 
    ReachabilityFlag1 = 1 << 15, 
    ReachabilityFlag2 = 1 << 16, 
 
    AutoRTFMConstructionAborted = 1 << 17, //< Object was constructed in an AutoRTFM transaction that has been aborted
    // Unused = 1 << 18,
    // Unused = 1 << 19,
    LoaderImport = 1 << 20, 
    Garbage = 1 << 21, 
    AsyncLoadingPhase1 = 1 << 22, 
    ReachableInCluster = 1 << 23, 
    ClusterRoot = 1 << 24, 
    Native = 1 << 25, 
    Async = 1 << 26, 
    AsyncLoadingPhase2 = 1 << 27, 
    Unreachable = 1 << 28, 
    RefCounted UE_DEPRECATED(5.7, "Use GetRefCount() to determine if a refcount exists instead.") = 1 << 29, 
    RootSet = 1 << 30, 
    PendingConstruction = 1 << 31, 
 
    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // DO NOT ADD composite flags to EInternalObjectFlags. Debugger visualisations have trouble displaying composite flag values as text.
    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
};
ENUM_CLASS_FLAGS(EInternalObjectFlags);
 
//~ Make sure these macros are up to date!
#define EInternalObjectFlags_MinFlagBitIndex 14
#define EInternalObjectFlags_RefCountMask 0xFFFFFFFF
#define EInternalObjectFlags_GarbageCollectionKeepFlags (EInternalObjectFlags::Borrowed | EInternalObjectFlags::Native | EInternalObjectFlags::Async | EInternalObjectFlags::AsyncLoadingPhase1 | EInternalObjectFlags::AsyncLoadingPhase2 | EInternalObjectFlags::LoaderImport)
#define EInternalObjectFlags_AllFlags (EInternalObjectFlags::Remote | EInternalObjectFlags::RemoteReference | EInternalObjectFlags::Borrowed | EInternalObjectFlags::ReachabilityFlag0 | EInternalObjectFlags::ReachabilityFlag1 | EInternalObjectFlags::ReachabilityFlag2 | EInternalObjectFlags::AutoRTFMConstructionAborted | EInternalObjectFlags::LoaderImport | EInternalObjectFlags::Garbage | EInternalObjectFlags::ReachableInCluster | EInternalObjectFlags::ClusterRoot | EInternalObjectFlags::Native | EInternalObjectFlags::Async | EInternalObjectFlags::AsyncLoadingPhase1 | EInternalObjectFlags::AsyncLoadingPhase2 | EInternalObjectFlags::RootSet | EInternalObjectFlags::PendingConstruction | EInternalObjectFlags::Unreachable)
#define EInternalObjectFlags_RootFlags (EInternalObjectFlags::RootSet | EInternalObjectFlags_GarbageCollectionKeepFlags)
#define EInternalObjectFlags_ReachabilityFlags (EInternalObjectFlags::ReachabilityFlag0 | EInternalObjectFlags::ReachabilityFlag1 | EInternalObjectFlags::ReachabilityFlag2 | EInternalObjectFlags::Unreachable)
#define EInternalObjectFlags_AsyncLoading (EInternalObjectFlags::AsyncLoadingPhase1 | EInternalObjectFlags::AsyncLoadingPhase2)
 
enum class EEnumFlags : uint8
{
    None,
 
    Flags = 0x00000001, // Whether the UEnum represents a set of flags
    NewerVersionExists = 0x00000002, // If set, this UEnum has been replaced by a newer version
};
 
ENUM_CLASS_FLAGS(EEnumFlags)
 
/*----------------------------------------------------------------------------
    Core types.
----------------------------------------------------------------------------*/
 
class UObject;
class FProperty;
class FObjectInitializer; 
 
struct FReferencerInformation 
{
    UObject*                Referencer;
 
    int32                       TotalReferences;
 
    TArray<const FProperty*>        ReferencingProperties;
 
    COREUOBJECT_API FReferencerInformation( UObject* inReferencer );
    COREUOBJECT_API FReferencerInformation( UObject* inReferencer, int32 InReferences, const TArray<const FProperty*>& InProperties );
};
 
struct FReferencerInformationList
{
    TArray<FReferencerInformation>      InternalReferences;
    TArray<FReferencerInformation>      ExternalReferences;
 
    COREUOBJECT_API FReferencerInformationList();
    COREUOBJECT_API FReferencerInformationList( const TArray<FReferencerInformation>& InternalRefs, const TArray<FReferencerInformation>& ExternalRefs );
};
 
/*----------------------------------------------------------------------------
    Core macros.
----------------------------------------------------------------------------*/
 
// Special prefix for default objects (the UObject in a UClass containing the default values, etc)
#define DEFAULT_OBJECT_PREFIX TEXT("Default__")
 
 
// These macros wrap metadata parsed by the Unreal Header Tool, and are otherwise
// ignored when code containing them is compiled by the C++ compiler
#define UPROPERTY(...)
#define UFUNCTION(...)
#define USTRUCT(...)
#define UMETA(...)
#define UPARAM(...)
#define UENUM(...)
#define UDELEGATE(...)
#define RIGVM_METHOD(...)
#define VMODULE(...)
 
// Used to inline generated cpp files from UObject headers
#define UE_INLINE_STRINGIFY(name) #name
#define UE_INLINE_GENERATED_CPP_BY_NAME(name) UE_INLINE_STRINGIFY(name.gen.cpp)
 
// This pair of macros is used to help implement GENERATED_BODY() and GENERATED_USTRUCT_BODY()
#define BODY_MACRO_COMBINE_INNER(A,B,C,D) A##B##C##D
#define BODY_MACRO_COMBINE(A,B,C,D) BODY_MACRO_COMBINE_INNER(A,B,C,D)
 
// Include a redundant semicolon at the end of the generated code block, so that intellisense parsers can start parsing
// a new declaration if the line number/generated code is out of date.
#define GENERATED_BODY_LEGACY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY_LEGACY);
#define GENERATED_BODY(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_GENERATED_BODY);
 
#define GENERATED_USTRUCT_BODY(...) GENERATED_BODY()
#define GENERATED_UCLASS_BODY(...) GENERATED_BODY_LEGACY()
#define GENERATED_UINTERFACE_BODY(...) GENERATED_BODY_LEGACY()
#define GENERATED_IINTERFACE_BODY(...) GENERATED_BODY_LEGACY()
 
#if UE_BUILD_DOCS || defined(__INTELLISENSE__ )
#define UCLASS(...)
#define VINTERFACES(...)
#else
#define UCLASS(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_PROLOG)
#define VINTERFACES(...) BODY_MACRO_COMBINE(CURRENT_FILE_ID,_,__LINE__,_VINTERFACES)
#endif
 
#define UINTERFACE(...) UCLASS()
 
// This macro is used to declare a thunk function in autogenerated boilerplate code
#define DECLARE_FUNCTION(func) static void func( UObject* Context, FFrame& Stack, RESULT_DECL )
 
// This macro is used to define a thunk function in autogenerated boilerplate code
#define DEFINE_FUNCTION(func) void func( UObject* Context, FFrame& Stack, RESULT_DECL )
 
// These are used for syntax highlighting and to allow autocomplete hints
 
namespace UC
{
    // valid keywords for the UCLASS macro
    enum 
    {
        classGroup,
 
        Within, /* =OuterClassName */
 
        BlueprintType,
 
        NotBlueprintType,
 
        Blueprintable,
 
        NotBlueprintable,
 
        MinimalAPI,
 
        customConstructor,
 
        CustomFieldNotify,
 
        Intrinsic,
 
        noexport,
 
        placeable,
 
        notplaceable,
 
        DefaultToInstanced,
 
        Const,
 
        Abstract,
 
        deprecated,
 
        Transient,
 
        nonTransient,
 
        Optional,
 
        config,
        perObjectConfig,
        configdonotcheckdefaults,
 
        defaultconfig,
 
        EditorConfig,
 
        editinlinenew,
        noteditinlinenew,
        hidedropdown,
 
        showCategories,
        hideCategories,
        ComponentWrapperClass,
        showFunctions,
        hideFunctions,
        autoExpandCategories,
        autoCollapseCategories,
        dontAutoCollapseCategories,
        collapseCategories,
        dontCollapseCategories,
        prioritizeCategories,
 
        AdvancedClassDisplay,
 
        ConversionRoot,
 
        Experimental,
 
        EarlyAccessPreview,
 
        SparseClassDataType,
 
        CustomThunkTemplates
    };
}
 
namespace UI
{
    // valid keywords for the UINTERFACE macro, see the UCLASS versions, above
    enum 
    {
        MinimalAPI,
 
        Blueprintable,
 
        NotBlueprintable,
 
        ConversionRoot,
    };
}
 
namespace UF
{
    // valid keywords for the UFUNCTION and UDELEGATE macros
    enum 
    {
        BlueprintImplementableEvent,
 
        BlueprintNativeEvent,
 
        SealedEvent,
 
        Exec,
 
        Server,
 
        Client,
 
        NetMulticast,
 
        Reliable,
 
        Unreliable,
 
        BlueprintPure,
 
        BlueprintCallable,
 
        BlueprintGetter,
 
        BlueprintSetter,
 
        BlueprintAuthorityOnly,
 
        BlueprintCosmetic,
 
        BlueprintInternalUseOnly,
    
        CallInEditor,
 
        CustomThunk,
 
        Category,
 
        FieldNotify,
 
        WithValidation,
 
        ServiceRequest,
 
        ServiceResponse,
        
        Variadic,
 
        ReturnDisplayName, 
 
        InternalUseParam, 
 
        // [FunctionMetadata] Indicates that the function should appear as blueprint function even if it doesn't return a value.
        ForceAsFunction, 
 
        IgnoreTypePromotion,
    };
}
 
namespace UP
{
    // valid keywords for the UPROPERTY macro
    enum 
    {
        Const,
 
        Config,
 
        GlobalConfig,
 
        Localized,
 
        Transient,
 
        DuplicateTransient,
 
        NonPIETransient,
 
        NonPIEDuplicateTransient,
 
        Ref,
 
        Export,
 
        NoClear,
 
        EditFixedSize,
 
        Replicated,
 
        ReplicatedUsing,
 
        NotReplicated,
 
        Interp,
 
        NonTransactional,
 
        Instanced,
 
        BlueprintAssignable,
 
        Category,
 
        SimpleDisplay,
 
        AdvancedDisplay,
 
        EditAnywhere,
 
        EditInstanceOnly,
 
        EditDefaultsOnly,
 
        VisibleAnywhere,
        
        VisibleInstanceOnly,
 
        VisibleDefaultsOnly,
 
        BlueprintReadOnly,
 
        BlueprintGetter,
 
        BlueprintReadWrite,
 
        BlueprintSetter,
 
        AssetRegistrySearchable,
 
        SaveGame,
 
        BlueprintCallable,
 
        BlueprintAuthorityOnly,
 
        TextExportTransient,
 
        SkipSerialization,
 
        HideSelfPin, 
 
        FieldNotify,
    };
}
 
namespace US
{
    // valid keywords for the USTRUCT macro
    enum 
    {
        NoExport,
 
        Atomic,
 
        Immutable,
 
        BlueprintType,
 
        BlueprintInternalUseOnly,
 
        BlueprintInternalUseOnlyHierarchical,
    };
}
 
// Metadata specifiers
namespace UM
{
    // Metadata usable in any UField (UCLASS(), USTRUCT(), UPROPERTY(), UFUNCTION(), etc...)
    enum
    {
        ToolTip,
 
        ShortTooltip,
 
        DocumentationPolicy,
    };
 
    // Metadata usable in UCLASS
    enum
    {
        BlueprintSpawnableComponent,
 
        ChildCanTick,
 
        ChildCannotTick,
        
        DebugTreeLeaf,
 
        IgnoreCategoryKeywordsInSubclasses,
 
        DeprecatedNode,
 
        DeprecationMessage,
 
        DisplayName,
 
        ScriptName,
 
        IsBlueprintBase,
 
        KismetHideOverrides,
 
        LoadBehavior,
 
        ProhibitedInterfaces,
 
        RestrictedToClasses,
 
        ShowWorldContextPin,
 
        //[ClassMetadata] Do not spawn an object of the class using Generic Create Object node in Blueprint. It makes sense only for a BluprintType class, that is neither Actor, nor ActorComponent.
        DontUseGenericSpawnObject,
 
        //[ClassMetadata] Expose a proxy object of this class in Async Task node.
        ExposedAsyncProxy,
 
        //[ClassMetadata] Only valid on Blueprint Function Libraries. Mark the functions in this class as callable on non-game threads in an Animation Blueprint.
        BlueprintThreadSafe,
 
        UsesHierarchy,
    };
 
    // Metadata usable in USTRUCT
    enum
    {
        HasNativeBreak,
 
        HasNativeMake,
 
        HiddenByDefault,
 
        DisableSplitPin,
    };
 
    // Metadata usable in UPROPERTY
    enum
    {
        AllowAbstract,
 
        AllowAnyActor,
 
        AllowedClasses,
 
        AllowPreserveRatio,
 
        AllowPrivateAccess,
 
        ArrayClamp,
 
        AssetBundles,
 
        BlueprintBaseOnly,
 
        BlueprintCompilerGeneratedDefaults,
 
        ClampMin,
 
        ClampMax,
 
        ConfigHierarchyEditable,
 
        ContentDir,
 
        Delta,
 
        DeprecatedProperty,
 
        // DeprecationMessage, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the property section)
 
        // DisplayName, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the property section)
 
        //ScriptName, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the property section)
 
        DisallowedAssetDataTags,
 
        DisallowedClasses,
 
        DisplayAfter,
 
        DisplayPriority,
 
        DisplayThumbnail,   
    
        EditCondition,
 
        EditConditionHides,
 
        EditFixedOrder,
        
        ExactClass,
 
        ExposeFunctionCategories,
 
        ExposeOnSpawn,
 
        FilePathFilter,
 
        RelativeToGameDir,
 
        FixedIncrement,
 
        ForceRebuildProperty,
 
        ForceShowEngineContent,
 
        ForceShowPluginContent,
 
        HideAlphaChannel,
 
        HideInDetailPanel,
 
        HideViewOptions,
 
        IgnoreForMemberInitializationTest,
 
        InlineEditConditionToggle,
 
        LinearDeltaSensitivity,
 
        // LoadBehavior, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the property section)
 
        LongPackageName,
 
        MakeEditWidget,
 
        MakeStructureDefaultValue,
 
        MetaClass,
 
        MustImplement,
 
        ObjectMustImplement,
 
        Multiple,
 
        MaxLength,
 
        MultiLine,
 
        PasswordField,
 
        NoElementDuplicate,
 
        NoResetToDefault,
 
        NoEditInline,
 
        NoSpinbox,
 
        OnlyPlaceable,
 
        RelativePath,
 
        RelativeToGameContentDir,
 
        RequiredAssetDataTags,
 
        ScriptNoExport,
 
        ShowOnlyInnerProperties,
 
        ShowTreeView,
 
        SliderExponent,
 
        TitleProperty,
 
        UIMin,
 
        UIMax,
 
        Units,
 
        ForceUnits,
 
        Untracked,
 
        DevelopmentOnly, 
 
        NeedsLatentFixup,
 
        LatentCallbackTarget,
 
        GetOptions,
 
        PinHiddenByDefault,
 
        ValidEnumValues,
 
        InvalidEnumValues,
 
        GetRestrictedEnumValues,
        
        GetAssetFilter,
        
        GetClassFilter,
        
        GetAllowedClasses,
        
        GetDisallowedClasses,
 
        AllowEditInlineCustomization,
 
        // HidePinAssetPicker, (Commented out so as to avoid duplicate name with version in the Function section, but still show in the property section)
    };
 
    // Metadata usable in UPROPERTY for customizing the behavior of Persona and UMG
    // TODO: Move this to be contained in those modules specifically?
    enum 
    {
        NeverAsPin, 
 
        PinShownByDefault, 
 
        AlwaysAsPin, 
 
        CustomizeProperty,
    };
 
    // Metadata usable in UPROPERTY for customizing the behavior of Material Expressions
    // TODO: Move this to be contained in that module?
    enum
    {
        OverridingInputProperty,
 
        RequiredInput,
    };
 
 
    // Metadata usable in UFUNCTION
    enum
    {
        AdvancedDisplay,
 
        ArrayParm,
 
        ArrayTypeDependentParams,
 
        AutoCreateRefTerm,
 
        HideAssetPicker UE_DEPRECATED(5.6, "Use HidePinAssetPicker instead."),
 
        HidePinAssetPicker,
 
        BlueprintInternalUseOnly,
 
        BlueprintProtected,
 
        CallableWithoutWorldContext,
 
        CommutativeAssociativeBinaryOperator,
 
        CompactNodeTitle,
 
        CustomStructureParam,
 
        DefaultToSelf,
 
        DeprecatedFunction,
 
        // DeprecationMessage, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the function section)
 
        ExpandEnumAsExecs,
 
        // Synonym for ExpandEnumAsExecs
        ExpandBoolAsExecs,
 
        // DisplayName, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the function section)
 
        //ScriptName, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the function section)
 
        //ScriptNoExport, (Commented out so as to avoid duplicate name with version in the Property section, but still show in the function section)
 
        ScriptMethod,
 
        ScriptMethodSelfReturn,
 
        ScriptMethodMutable,
 
        ScriptOperator,
 
        ScriptConstant,
 
        ScriptConstantHost,
 
        HidePin,
 
        HideSpawnParms,
 
        Keywords,
 
        Latent,
 
        LatentInfo,
 
        MaterialParameterCollectionFunction,
 
        NativeBreakFunc,
 
        NativeMakeFunc,
 
        UnsafeDuringActorConstruction,
 
        WorldContext,
 
        BlueprintAutocast,
 
        // [FunctionMetadata] Only valid in Blueprint Function Libraries. Mark this function as an exception to the class's general BlueprintThreadSafe metadata.
        NotBlueprintThreadSafe,
 
        DeterminesOutputType,
 
        DynamicOutputParam,
 
        DataTablePin,
 
        SetParam,
 
        MapParam,
 
        MapKeyParam,
 
        MapValueParam,
 
        Bitmask,
 
        BitmaskEnum,
 
        Bitflags,
 
        UseEnumValuesAsMaskValuesInEditor,
 
        AnimBlueprintFunction,
 
        ArrayParam,
    };
 
    // Metadata usable in UINTERFACE
    enum
    {
        CannotImplementInterfaceInBlueprint,
 
        CannotGenerateMessageNodes
    };
}
 
#define RELAY_CONSTRUCTOR(TClass, TSuperClass) TClass(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get()) : TSuperClass(ObjectInitializer) {}
#define UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) TClass(const TClass&) = delete; TClass(TClass&&) = delete;
 
#if !USE_COMPILED_IN_NATIVES
#define COMPILED_IN_FLAGS(TStaticFlags) (TStaticFlags& ~(CLASS_Intrinsic))
#else
#define COMPILED_IN_FLAGS(TStaticFlags) (TStaticFlags | CLASS_Intrinsic)
#endif
 
#define DECLARE_SERIALIZER( TClass ) \
    friend FArchive &operator<<( FArchive& Ar, TClass*& Res ) \
    { \
        return Ar << (UObject*&)Res; \
    } \
    friend void operator<<(FStructuredArchive::FSlot InSlot, TClass*& Res) \
    { \
        InSlot << (UObject*&)Res; \
    }
 
#define IMPLEMENT_FARCHIVE_SERIALIZER( TClass ) void TClass::Serialize(FArchive& Ar) { TClass::Serialize(FStructuredArchiveFromArchive(Ar).GetSlot().EnterRecord()); }
#define IMPLEMENT_FSTRUCTUREDARCHIVE_SERIALIZER( TClass ) void TClass::Serialize(FStructuredArchive::FRecord Record) { FArchiveUObjectFromStructuredArchive Ar(Record.EnterField(TEXT("BaseClassAutoGen"))); TClass::Serialize(Ar.GetArchive()); Ar.Close(); }
#define DECLARE_FARCHIVE_SERIALIZER( TClass, API ) virtual API void Serialize(FArchive& Ar) override;
#define DECLARE_FSTRUCTUREDARCHIVE_SERIALIZER( TClass, API ) virtual API void Serialize(FStructuredArchive::FRecord Record) override;
 
#if WITH_RELOAD
#define CONSTRUCT_RELOAD_VERSION_INFO(VersionInfo, ...) VersionInfo { __VA_ARGS__ }
#else
#define CONSTRUCT_RELOAD_VERSION_INFO(VersionInfo, ...) VersionInfo()
#endif
 
/*-----------------------------------------------------------------------------
    Class declaration macros.
-----------------------------------------------------------------------------*/
 
#define DECLARE_CLASS( TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, TRequiredAPI ) \
    TRequiredAPI static UClass* GetPrivateStaticClass(); \
    DECLARE_CLASS2(TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, GetPrivateStaticClass )
 
#define DECLARE_CLASS2( TClass, TSuperClass, TStaticFlags, TStaticCastFlags, TPackage, TPrivateAccessor ) \
private: \
    friend struct FUObjectCppClassStaticFunctions; \
public: \
 \
    static constexpr EClassFlags StaticClassFlags=EClassFlags(TStaticFlags); \
 \
    typedef TSuperClass Super;\
 \
    typedef TClass ThisClass;\
 \
    inline static UClass* StaticClass() \
    { \
        return TPrivateAccessor(); \
    } \
 \
    inline static const TCHAR* StaticPackage() \
    { \
        return TPackage; \
    } \
 \
    inline constexpr static EClassCastFlags StaticClassCastFlags() \
    { \
        return TStaticCastFlags; \
    } \
 \
    inline consteval static EClassCastFlags StaticAllClassCastFlags() \
    { \
        if constexpr (std::is_same_v<ThisClass, Super>) { return StaticClassCastFlags(); } \
        return StaticClassCastFlags() | Super::StaticAllClassCastFlags(); \
    } \
 \
    inline void* operator new(const size_t InSize, EInternal InInternalOnly, UObject* InOuter = GetTransientPackageAsObject(), FName InName = NAME_None, EObjectFlags InSetFlags = RF_NoFlags) \
    { \
        return StaticAllocateObject(StaticClass(), InOuter, InName, InSetFlags); \
    } \
 \
    inline void* operator new( const size_t InSize, EInternal* InMem ) \
    { \
        return (void*)InMem; \
    } \
    /* Eliminate V1062 warning from PVS-Studio while keeping MSVC and Clang happy. */ \
    inline void operator delete(void* InMem) \
    { \
        ::operator delete(InMem); \
    }
 
#define DEFINE_FORBIDDEN_DEFAULT_CONSTRUCTOR_CALL(TClass) \
    static_assert(false, "You have to define " #TClass "::" #TClass "() or " #TClass "::" #TClass "(const FObjectInitializer&). This is required by UObject system to work correctly.");
 
#define DEFINE_DEFAULT_CONSTRUCTOR_CALL(TClass) \
    static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass; }
 
#define DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void __DefaultConstructor(const FObjectInitializer& X) { new((EInternal*)X.GetObj())TClass(X); }
 
#if CHECK_PUREVIRTUALS
#define DEFINE_ABSTRACT_DEFAULT_CONSTRUCTOR_CALL(TClass) \
    static void __DefaultConstructor(const FObjectInitializer& X) { }
 
#define DEFINE_ABSTRACT_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void __DefaultConstructor(const FObjectInitializer& X) { }
#else
#define DEFINE_ABSTRACT_DEFAULT_CONSTRUCTOR_CALL(TClass) \
    DEFINE_DEFAULT_CONSTRUCTOR_CALL(TClass)
 
#define DEFINE_ABSTRACT_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass)
#endif
 
#define DECLARE_VTABLE_PTR_HELPER_CTOR(API, TClass) \
 \
    API TClass(FVTableHelper& Helper);
 
// Namespace should be in the form of "Whatever::" or blank for no namespace
#define DEFINE_VTABLE_PTR_HELPER_CTOR_NS(Namespace, TClass) \
    Namespace TClass::TClass(FVTableHelper& Helper) : Super(Helper) {};
 
#define DEFINE_VTABLE_PTR_HELPER_CTOR(TClass) DEFINE_VTABLE_PTR_HELPER_CTOR_NS(, TClass)
 
#define DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY() \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return nullptr; \
    }
 
#if WITH_RELOAD && !CHECK_PUREVIRTUALS
    #define DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(TClass) \
        static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
        { \
            return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
        }
#else // WITH_RELOAD && !CHECK_PUREVIRTUALS
    #define DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER(TClass) \
        DEFINE_VTABLE_PTR_HELPER_CTOR_CALLER_DUMMY()
#endif // WITH_RELOAD && !CHECK_PUREVIRTUALS
 
#define DECLARE_CLASS_INTRINSIC_NO_CTOR(TClass,TSuperClass,TStaticFlags,TPackage) \
    DECLARE_CLASS(TClass, TSuperClass, TStaticFlags | CLASS_Intrinsic, CASTCLASS_None, TPackage, NO_API) \
    static void StaticRegisterNatives##TClass() {} \
    DECLARE_SERIALIZER(TClass) \
    UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
    DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }
 
#define DECLARE_CLASS_INTRINSIC(TClass,TSuperClass,TStaticFlags,TPackage) \
    DECLARE_CLASS_INTRINSIC_API(TClass,TSuperClass,TStaticFlags,TPackage, NO_API)
 
#define DECLARE_CLASS_INTRINSIC_API(TClass,TSuperClass,TStaticFlags,TPackage, TRequiredAPI) \
    DECLARE_CLASS(TClass,TSuperClass,TStaticFlags|CLASS_Intrinsic,CASTCLASS_None,TPackage,TRequiredAPI) \
    RELAY_CONSTRUCTOR(TClass, TSuperClass) \
    UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
 \
    TClass(FVTableHelper& Helper) : Super(Helper) {}; \
    static void StaticRegisterNatives##TClass() {} \
    DECLARE_SERIALIZER(TClass) \
    DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }
 
#define DECLARE_CASTED_CLASS_INTRINSIC_WITH_API_NO_CTOR( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI ) \
    DECLARE_CLASS(TClass, TSuperClass, TStaticFlags | CLASS_Intrinsic, TStaticCastFlags, TPackage, TRequiredAPI) \
    UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
    static void StaticRegisterNatives##TClass() {} \
    DECLARE_SERIALIZER(TClass) \
    DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }
 
#define DECLARE_CASTED_CLASS_INTRINSIC_WITH_API( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI ) \
    DECLARE_CLASS(TClass,TSuperClass,TStaticFlags|CLASS_Intrinsic,TStaticCastFlags,TPackage,TRequiredAPI ) \
    RELAY_CONSTRUCTOR(TClass, TSuperClass) \
    UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
 \
    TClass(FVTableHelper& Helper) : Super(Helper) {}; \
    static void StaticRegisterNatives##TClass() {} \
    DECLARE_SERIALIZER(TClass) \
    DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }
 
#define DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI ) \
    DECLARE_CLASS(TClass,TSuperClass,TStaticFlags|CLASS_Intrinsic,TStaticCastFlags,TPackage, TRequiredAPI ) \
    UE_DELETE_COPY_MOVE_CONSTRUCTORS(TClass) \
    static void StaticRegisterNatives##TClass() {} \
    DECLARE_SERIALIZER(TClass) \
    DEFINE_DEFAULT_OBJECT_INITIALIZER_CONSTRUCTOR_CALL(TClass) \
    static void IntrinsicClassInit(UClass* Class); \
    static UObject* __VTableCtorCaller(FVTableHelper& Helper) \
    { \
        return new (EC_InternalUseOnlyConstructor, GetTransientPackageAsObject(), NAME_None, RF_NeedLoad | RF_ClassDefaultObject | RF_TagGarbageTemp) TClass(Helper); \
    }
 
#define DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI ) \
    DECLARE_CASTED_CLASS_INTRINSIC_NO_CTOR_NO_VTABLE_CTOR( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, TRequiredAPI ) \
 \
    TClass(FVTableHelper& Helper) : Super(Helper) {}; \
 
 
#define DECLARE_CASTED_CLASS_INTRINSIC( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags ) \
    DECLARE_CASTED_CLASS_INTRINSIC_WITH_API( TClass, TSuperClass, TStaticFlags, TPackage, TStaticCastFlags, NO_API) \
 
// Declare that objects of class being defined reside within objects of the specified class.
#define DECLARE_WITHIN_INTERNAL( TWithinClass, bCanUseOnCDO ) \
 \
    typedef class TWithinClass WithinClass;  \
    TWithinClass* GetOuter##TWithinClass() const { return (ensure(bCanUseOnCDO || !HasAnyFlags(RF_ClassDefaultObject)) ? (TWithinClass*)GetOuter() : nullptr); }
 
#define DECLARE_WITHIN( TWithinClass ) \
    DECLARE_WITHIN_INTERNAL( TWithinClass, false )
 
#define DECLARE_WITHIN_UPACKAGE() \
    DECLARE_WITHIN_INTERNAL( UPackage, true )
 
#define UOBJECT_CPPCLASS_STATICFUNCTIONS_ALLCONFIGS(TClass) \
    FUObjectCppClassStaticFunctions::AddReferencedObjectsType(&TClass::AddReferencedObjects)
    /* UObjectCppClassStaticFunctions: Extend this macro with the address of your new static function, if it applies to all configs. */
    /* Order must match the order in the FUObjectCppClassStaticFunctions constructor. */
 
#if WITH_EDITORONLY_DATA
    #define UOBJECT_CPPCLASS_STATICFUNCTIONS_WITHEDITORONLYDATA(TClass) \
        , FUObjectCppClassStaticFunctions::DeclareCustomVersionsType(&TClass::DeclareCustomVersions) \
        , FUObjectCppClassStaticFunctions::AppendToClassSchemaType(&TClass::AppendToClassSchema) \
        , FUObjectCppClassStaticFunctions::DeclareConstructClassesType(&TClass::DeclareConstructClasses)
        /* UObjectCppClassStaticFunctions: Extend this macro with the address of your new static function, if it is editor-only. */
        /* Order must match the order in the FUObjectCppClassStaticFunctions constructor. */
 
#else
    #define UOBJECT_CPPCLASS_STATICFUNCTIONS_WITHEDITORONLYDATA(TClass)
#endif
 
#define UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass) \
    FUObjectCppClassStaticFunctions \
    ( \
        UOBJECT_CPPCLASS_STATICFUNCTIONS_ALLCONFIGS(TClass) \
        UOBJECT_CPPCLASS_STATICFUNCTIONS_WITHEDITORONLYDATA(TClass) \
    )
 
struct FUObjectCppClassStaticFunctions
{
public:
    typedef void (*AddReferencedObjectsType)    (UObject* ThisObject, FReferenceCollector& Ar);
#if WITH_EDITORONLY_DATA
    typedef void (*DeclareCustomVersionsType)   (FArchive& Ar, const UClass* SpecificSubclass);
    typedef void (*AppendToClassSchemaType)   (FAppendToClassSchemaContext& Context);
    typedef void (*DeclareConstructClassesType)   (TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
    // UObjectCppClassStaticFunctions: Extend this list of types with the type of your new static function.
 
    // Take a null ptr of the class for template type deduction, then this class can be declared a friend of generated classes to access their member function pointers
    template<typename TClass>
    explicit consteval FUObjectCppClassStaticFunctions(TClass* Null)
    : UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass)
    {
    }
 
    explicit constexpr FUObjectCppClassStaticFunctions(AddReferencedObjectsType InAddReferencedObjects
#if WITH_EDITORONLY_DATA
        , DeclareCustomVersionsType InDeclareCustomVersions
        , AppendToClassSchemaType InAppendToClassSchema
        , DeclareConstructClassesType InDeclareConstructClasses
#endif
    )
        : AddReferencedObjects(InAddReferencedObjects)
#if WITH_EDITORONLY_DATA
        , DeclareCustomVersions(InDeclareCustomVersions)
        , AppendToClassSchema(InAppendToClassSchema)
        , DeclareConstructClasses(InDeclareConstructClasses)
#endif
    {
        // Null elements are not valid in this constructor
        check(InAddReferencedObjects);
#if WITH_EDITORONLY_DATA
        check(InDeclareCustomVersions);
        check(InAppendToClassSchema);
        check(InDeclareConstructClasses);
#endif
        // UObjectCppClassStaticFunctions: Extend the constructor with initializers for your new static function member.
        // Order must match the order in UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS.
    }
public:
    FUObjectCppClassStaticFunctions() = default;
    bool IsInitialized() const
    {
        // All methods that set the functions in this class guarantee that if any function is non-null, they all are.
        // So we only need to check the first one to know whether we are completely initialized.
        return AddReferencedObjects != nullptr;
    }
    void Reset()
    {
        *this = FUObjectCppClassStaticFunctions();
    }
 
public:
    AddReferencedObjectsType GetAddReferencedObjects() const
    {
        return AddReferencedObjects;
    }
    void SetAddReferencedObjects(AddReferencedObjectsType InAddReferencedObjects)
    {
        check(InAddReferencedObjects != nullptr); // It is not valid to clear single elements (see IsInitialized). Call Reset to clear all elements.
        AddReferencedObjects = InAddReferencedObjects;
    }
#if WITH_EDITORONLY_DATA
    DeclareCustomVersionsType GetDeclareCustomVersions() const
    {
        return DeclareCustomVersions;
    }
    void SetDeclareCustomVersions(DeclareCustomVersionsType InDeclareCustomVersions)
    {
        check(InDeclareCustomVersions != nullptr); // It is not valid to clear single elements (see IsInitialized). Call Reset to clear all elements.
        DeclareCustomVersions = InDeclareCustomVersions;
    }
    AppendToClassSchemaType GetAppendToClassSchema() const
    {
        return AppendToClassSchema;
    }
    void SetAppendToClassSchema(AppendToClassSchemaType InAppendToClassSchema)
    {
        check(InAppendToClassSchema != nullptr); // It is not valid to clear single elements (see IsInitialized). Call Reset to clear all elements.
        AppendToClassSchema = InAppendToClassSchema;
    }
    DeclareConstructClassesType GetDeclareConstructClasses() const
    {
        return DeclareConstructClasses;
    }
    void SetDeclareConstructClasses(DeclareConstructClassesType InDeclareConstructClasses)
    {
        check(InDeclareConstructClasses != nullptr); // It is not valid to clear single elements (see IsInitialized). Call Reset to clear all elements.
        DeclareConstructClasses = InDeclareConstructClasses;
    }
#endif
    // UObjectCppClassStaticFunctions: Extend the list of accessors for your new static function.
 
private:
    AddReferencedObjectsType AddReferencedObjects = nullptr;
#if WITH_EDITORONLY_DATA
    DeclareCustomVersionsType DeclareCustomVersions = nullptr;
    AppendToClassSchemaType AppendToClassSchema = nullptr;
    DeclareConstructClassesType DeclareConstructClasses = nullptr;
#endif
    // UObjectCppClassStaticFunctions: Extend this list of members with the member for your new static function.
 
};
 
// Implement the GetPrivateStaticClass and the registration info but do not auto register the class.  
// This is no longer used by UnrealHeaderTool
#if !UE_WITH_CONSTINIT_UOBJECT
#define IMPLEMENT_CLASS_NO_AUTO_REGISTRATION(TClass) \
    FClassRegistrationInfo Z_Registration_Info_UClass_##TClass; \
    UClass* TClass::GetPrivateStaticClass() \
    { \
        if (!Z_Registration_Info_UClass_##TClass.InnerSingleton) \
        { \
            /* this could be handled with templates, but we want it external to avoid code bloat */ \
            GetPrivateStaticClassBody( \
                StaticPackage(), \
                (TCHAR*)TEXT(#TClass) + 1 + ((StaticClassFlags & CLASS_Deprecated) ? 11 : 0), \
                Z_Registration_Info_UClass_##TClass.InnerSingleton, \
                StaticRegisterNatives##TClass, \
                sizeof(TClass), \
                alignof(TClass), \
                TClass::StaticClassFlags, \
                TClass::StaticClassCastFlags(), \
                TClass::StaticConfigName(), \
                (UClass::ClassConstructorType)InternalConstructor<TClass>, \
                (UClass::ClassVTableHelperCtorCallerType)InternalVTableHelperCtorCaller<TClass>, \
                UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass), \
                &TClass::Super::StaticClass, \
                &TClass::WithinClass::StaticClass \
            ); \
        } \
        return Z_Registration_Info_UClass_##TClass.InnerSingleton; \
    }
#endif // !UE_WITH_CONSTINIT_UOBJECT
 
// Register a class at startup time.
#if !UE_WITH_CONSTINIT_UOBJECT
#define IMPLEMENT_CLASS(TClass, TClassCrc) \
    IMPLEMENT_CLASS_NO_AUTO_REGISTRATION(TClass) \
    /* Do not change the AutoInitialize_ without changing LC_SymbolPatterns */ \
    static FRegisterCompiledInInfo AutoInitialize_##TClass(&Z_Construct_UClass_##TClass, TClass::StaticClass, TClass::StaticPackage(), TEXT(#TClass), Z_Registration_Info_UClass_##TClass, CONSTRUCT_RELOAD_VERSION_INFO(FClassReloadVersionInfo, sizeof(TClass), TClassCrc));
#endif // !UE_WITH_CONSTINIT_UCLASS
 
#if UE_WITH_CONSTINIT_UOBJECT
#define IMPLEMENT_INTRINSIC_CLASS(TClass, TRequiredAPI, TSuperClass, TSuperRequiredAPI, TPackage, InitCode) \
    IMPLEMENT_INTRINSIC_CLASS_CONSTINIT(TClass, TRequiredAPI, TSuperClass, TSuperRequiredAPI, TPackage, InitCode)
// Used for intrinsics, this sets up the boiler plate, plus an initialization singleton, which can create properties and GC tokens
#else
#define IMPLEMENT_INTRINSIC_CLASS(TClass, TRequiredAPI, TSuperClass, TSuperRequiredAPI, TPackage, InitCode) \
    TRequiredAPI UClass* Z_Construct_UClass_##TClass(); \
    extern FClassRegistrationInfo Z_Registration_Info_UClass_##TClass; \
    struct Z_Construct_UClass_##TClass##_Statics \
    { \
        static UClass* Construct() \
        { \
            extern TSuperRequiredAPI UClass* Z_Construct_UClass_##TSuperClass(); \
            UClass* SuperClass = Z_Construct_UClass_##TSuperClass(); \
            UClass* Class = TClass::StaticClass(); \
            UObjectForceRegistration(Class); \
            check(Class->GetSuperClass() == SuperClass); \
            TClass::IntrinsicClassInit(Class); \
            Class->StaticLink(); \
            return Class; \
        } \
    }; \
    void TClass::IntrinsicClassInit(UClass* Class) \
    { \
        InitCode \
    } \
    UClass* Z_Construct_UClass_##TClass() \
    { \
        if (!Z_Registration_Info_UClass_##TClass.OuterSingleton) \
        { \
            Z_Registration_Info_UClass_##TClass.OuterSingleton = Z_Construct_UClass_##TClass##_Statics::Construct();\
        } \
        check(Z_Registration_Info_UClass_##TClass.OuterSingleton->GetClass()); \
        return Z_Registration_Info_UClass_##TClass.OuterSingleton; \
    } \
    IMPLEMENT_CLASS(TClass, 0)
 
#endif
 
#if UE_WITH_CONSTINIT_UOBJECT
// CONSTINIT_UOBJECT_TODO: Should intrinsic classes inherit class flags here rather than waiting until Link?
#define IMPLEMENT_INTRINSIC_CLASS_CONSTINIT(TClass, TRequiredAPI, TSuperClass, TSuperRequiredAPI, TPackage, InitCode) \
    static constinit FCppClassTypeInfoStatic Z_StaticCppClassTypeInfo_##TClass = { \
        TCppClassTypeTraits<TClass>::IsAbstract, \
    }; \
    constinit extern UPackage Z_ConstInit_UPackage__Script_##TPackage; \
    constinit extern TNoDestroy<UClass> Z_ConstInit_UClass_UClass; \
    constinit extern TNoDestroy<UClass> Z_ConstInit_UClass_##TSuperClass; \
    constinit TNoDestroy<UClass> Z_ConstInit_UClass_##TClass{NoDestroyConstEval, \
        UE::CodeGen::ConstInit::FObjectParams{ \
            .Flags = RF_Public|RF_Transient|RF_MarkAsNative|RF_MarkAsRootSet, \
            .Class = std::is_same_v<UClass, TClass> ? nullptr : &Z_ConstInit_UClass_UClass, \
            /* Trim the U/A prefix which is still a single byte in UTF8 */ \
            .NameUTF8 = &UTF8TEXT(UE_STRINGIZE(TClass))[1], \
            .Outer = &Z_ConstInit_UPackage__Script_##TPackage, \
        }, \
        UE::CodeGen::ConstInit::FUFieldParams{}, \
        UE::CodeGen::ConstInit::FStructParams{ \
            .Super = &Z_ConstInit_UClass_##TSuperClass, \
            .BaseChain = TIntrinsicClassBaseChain<TClass>::ToArrayView(), \
            .PropertiesSize = sizeof(TClass), \
            .MinAlignment = alignof(TClass), \
        }, \
        UE::CodeGen::ConstInit::FClassParams{ \
            .ConfigName = TClass::StaticConfigName(), \
            .ClassConstructor = InternalConstructor<TClass>, \
            .ClassVTableHelperCtorCaller = InternalVTableHelperCtorCaller<TClass>, \
            .CppClassStaticFunctions = UOBJECT_CPPCLASS_STATICFUNCTIONS_FORCLASS(TClass), \
            .ClassFlags = TClass::StaticClassFlags, \
            .ClassCastFlags = TClass::StaticAllClassCastFlags(), \
            .CppClassTypeInfo = &Z_StaticCppClassTypeInfo_##TClass, \
            .ClassWithin = UE::Private::GetConstInitClass<TClass::WithinClass>(), \
        }, \
    }; \
    struct Z_Construct_UClass_##TClass##_Statics { \
        static void Construct() \
        { \
            UClass* SuperClass = TSuperClass::StaticClass(); \
            UClass* Class = TClass::StaticClass(); \
            InitCode; \
        } \
    }; \
    static FRegisterCompiledInObjects Z_Register_UClass_##TClass{ &Z_ConstInit_UClass_##TClass, &Z_Construct_UClass_##TClass##_Statics::Construct }; \
    TRequiredAPI UClass* TClass::GetPrivateStaticClass() \
    { \
        return &Z_ConstInit_UClass_##TClass; \
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
 
#if UE_WITH_CONSTINIT_UOBJECT
#define IMPLEMENT_CORE_INTRINSIC_CLASS(TClass, TSuperClass, InitCode) \
    IMPLEMENT_INTRINSIC_CLASS_CONSTINIT(TClass, COREUOBJECT_API, TSuperClass, COREUOBJECT_API, CoreUObject, InitCode)
#else
#define IMPLEMENT_CORE_INTRINSIC_CLASS(TClass, TSuperClass, InitCode) \
    IMPLEMENT_INTRINSIC_CLASS(TClass, COREUOBJECT_API, TSuperClass, COREUOBJECT_API, CoreUObject, InitCode)
#endif
 
typedef uint32 ERenameFlags;
 
#define REN_None                        (0x0000)
#define REN_ForceNoResetLoaders         (0x0001) 
#define REN_Test                        (0x0002) 
#define REN_DoNotDirty                  (0x0004) 
#define REN_DontCreateRedirectors       (0x0010) 
#define REN_NonTransactional            (0x0020) 
#define REN_ForceGlobalUnique           (0x0040) 
#define REN_SkipGeneratedClasses        (0x0080) 
#define REN_SkipComponentRegWork        (0x0100) 
#define REN_AllowPackageLinkerMismatch  (0x0200) 
 
/*-----------------------------------------------------------------------------
    Misc.
-----------------------------------------------------------------------------*/
 
typedef void (*FAsyncCompletionCallback)( UObject* LinkerRoot, void* CallbackUserData );
 
namespace GameplayTagsManager
{
    enum
    {
        Categories,
        
        GameplayTagFilter,
    };
}
 
/*-----------------------------------------------------------------------------
    UObject.
-----------------------------------------------------------------------------*/
 
namespace UE
{
    enum ELoadConfigPropagationFlags
    {
        LCPF_None                   =   0x0,
 
        LCPF_ReadParentSections     =   0x1,
 
        LCPF_PropagateToChildDefaultObjects     =   0x2,
 
        LCPF_PropagateToInstances   =   0x4,
 
        LCPF_ReloadingConfigData    =   0x8,
 
        LCPF_PersistentFlags        =   LCPF_ReloadingConfigData,
    };
}
 
namespace UE4
{
    using ELoadConfigPropagationFlags UE_DEPRECATED(5.0, "Use UE namespace instead of UE4") = UE::ELoadConfigPropagationFlags;
 
    UE_DEPRECATED(5.0, "Use UE namespace instead of UE4") inline constexpr UE::ELoadConfigPropagationFlags LCPF_None                            = UE::ELoadConfigPropagationFlags::LCPF_None;
    UE_DEPRECATED(5.0, "Use UE namespace instead of UE4") inline constexpr UE::ELoadConfigPropagationFlags LCPF_ReadParentSections              = UE::ELoadConfigPropagationFlags::LCPF_ReadParentSections;
    UE_DEPRECATED(5.0, "Use UE namespace instead of UE4") inline constexpr UE::ELoadConfigPropagationFlags LCPF_PropagateToChildDefaultObjects  = UE::ELoadConfigPropagationFlags::LCPF_PropagateToChildDefaultObjects;
    UE_DEPRECATED(5.0, "Use UE namespace instead of UE4") inline constexpr UE::ELoadConfigPropagationFlags LCPF_PropagateToInstances            = UE::ELoadConfigPropagationFlags::LCPF_PropagateToInstances;
    UE_DEPRECATED(5.0, "Use UE namespace instead of UE4") inline constexpr UE::ELoadConfigPropagationFlags LCPF_ReloadingConfigData             = UE::ELoadConfigPropagationFlags::LCPF_ReloadingConfigData;
    UE_DEPRECATED(5.0, "Use UE namespace instead of UE4") inline constexpr UE::ELoadConfigPropagationFlags LCPF_PersistentFlags                 = UE::ELoadConfigPropagationFlags::LCPF_PersistentFlags;
}
 
 
class FRestoreForUObjectOverwrite
{
public:
    virtual ~FRestoreForUObjectOverwrite() {}
    virtual void Restore() const=0;
};
 
#ifndef VALIDATE_CLASS_REPS
#define VALIDATE_CLASS_REPS DO_CHECK
#endif
 
#if VALIDATE_CLASS_REPS
#define DECLARE_VALIDATE_GENERATED_REP_ENUMS( API ) API virtual void ValidateGeneratedRepEnums(const TArray<struct FRepRecord>& ClassReps) const override;
#else
#define DECLARE_VALIDATE_GENERATED_REP_ENUMS( API )
#endif