Class.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    Class.h: UClass definition.
=============================================================================*/
 
#pragma once
 
#include "Concepts/GetTypeHashable.h"
#include "Concepts/StaticClassProvider.h"
#include "Concepts/StaticStructProvider.h"
#include "Concepts/StructSerializableWithDefaults.h"
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/EnumAsByte.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Algo/MaxElement.h"
#include "Async/Mutex.h"
#include "Async/SharedLock.h"
#include "Async/SharedMutex.h"
#include "Async/UniqueLock.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformCrt.h"
#include "HAL/UnrealMemory.h"
#include "Internationalization/Text.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Logging/LogVerbosity.h"
#include "Math/Box2D.h"
#include "Math/InterpCurvePoint.h"
#include "Math/MathFwd.h"
#include "Math/Matrix.h"
#include "Math/Plane.h"
#include "Math/Quat.h"
#include "Math/RandomStream.h"
#include "Math/Rotator.h"
#include "Math/Transform.h"
#include "Math/Vector2D.h"
#include "Math/Vector4.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/FallbackStruct.h"
#include "Misc/Guid.h"
#include "Misc/NotNull.h"
#include "Misc/Optional.h"
#include "Misc/ScopeRWLock.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveAdapters.h"
#include "Templates/AlignmentTemplates.h"
#include "Templates/EnableIf.h"
#include "Templates/Identity.h"
#include "Templates/IsAbstract.h"
#include "Templates/IsEnum.h"
#include "Templates/IsPODType.h"
#include "Templates/IsUECoreType.h"
#include "Templates/Models.h"
#include "Templates/NoDestroy.h"
#include "Templates/Tuple.h"
#include "Templates/TypeCompatibleBytes.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "Trace/Detail/Channel.h"
#include "UObject/CoreNative.h"
#include "UObject/Field.h"
#include "UObject/FieldPath.h"
#include "UObject/GarbageCollection.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/PropertyTag.h"
#include "UObject/PropertyVisitor.h"
#include "UObject/ReflectedTypeAccessors.h"
#include "UObject/Script.h"
#include "UObject/StructOpsTypeTraits.h"
#include "UObject/TopLevelAssetPath.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/ObjectPtr.h"
#include "UObject/ObjectPtrLinkedListBuilder.h"
#include "UObject/ObjectPtrLinkedListIterator.h"
#include <type_traits>
#include <atomic>
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_5
#include "Templates/IsTriviallyDestructible.h"
#endif
 
#include "Class.generated.h"
 
class FArchive;
class FEditPropertyChain;
class FField;
class FOutputDevice;
class FProperty;
class FReferenceCollector;
class FStructProperty;
class FStructuredArchiveRecord;
class UObject;
class UPackageMap;
class UPropertyWrapper;
struct CGetTypeHashable;
struct FArchiveFieldName;
struct FAssetData;
struct FBlake3Hash;
struct FColor;
struct FCustomPropertyListNode;
struct FDoubleInterval;
struct FDoubleRange;
struct FDoubleRangeBound;
struct FFallbackStruct;
struct FFloatInterval;
struct FFloatRange;
struct FFloatRangeBound;
struct FFrame;
struct FInt32Interval;
struct FInt32Range;
struct FInt32RangeBound;
struct FInterpCurveFloat;
struct FInterpCurveLinearColor;
struct FInterpCurveQuat;
struct FInterpCurveTwoVectors;
struct FInterpCurveVector2D;
struct FInterpCurveVector;
struct FLinearColor;
struct FNetDeltaSerializeInfo;
struct FObjectInstancingGraph;
struct FPropertyTag;
struct FRandomStream;
struct FUObjectSerializeContext;
template <typename FuncType> class TFunctionRef;
enum class EPropertyObjectReferenceType : uint32;
 
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogClass, Log, All);
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogScriptSerialization, Log, All);
 
#if UE_WITH_CONSTINIT_UOBJECT
    typedef UE::TSharedLock<UE::FSharedMutex> FUClassFuncScopeReadLock;
    typedef UE::TUniqueLock<UE::FSharedMutex> FUClassFuncScopeWriteLock;
    typedef UE::FSharedMutex FUClassFuncLock;
#elif PLATFORM_FORCE_UE_LOCK_USAGE
    typedef UE::TUniqueLock<UE::FMutex> FUClassFuncScopeReadLock;
    typedef UE::TUniqueLock<UE::FMutex> FUClassFuncScopeWriteLock;
    typedef UE::FMutex FUClassFuncLock;
#else
    typedef FReadScopeLock FUClassFuncScopeReadLock;
    typedef FWriteScopeLock FUClassFuncScopeWriteLock;
    typedef FRWLock FUClassFuncLock;
#endif
 
 
/*-----------------------------------------------------------------------------
    FRepRecord.
-----------------------------------------------------------------------------*/
 
//
// Information about a property to replicate.
//
struct FRepRecord
{
    FProperty* Property;
    int32 Index;
    FRepRecord(FProperty* InProperty,int32 InIndex)
    : Property(InProperty), Index(InIndex)
    {}
};
 
/*-----------------------------------------------------------------------------
    UField.
-----------------------------------------------------------------------------*/
 
//
// Base class of reflection data objects.
//
UCLASS(MinimalAPI, Abstract, Config = Engine)
class UField : public UObject
{
    GENERATED_BODY()
public:
 
    typedef UField BaseFieldClass;
    typedef UClass FieldTypeClass;
 
    UPROPERTY(SkipSerialization)
    TObjectPtr<UField>          Next;
 
    // Constructors.
    UField(const FObjectInitializer& ObjectInitializer) 
    : Super(ObjectInitializer)
    {
    }
 
    UField(EStaticConstructor, EObjectFlags InFlags);
    
#if UE_WITH_CONSTINIT_UOBJECT
    consteval UField(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams
    )
        : Super(ObjectParams)
        , Next(FieldParams.Next)
    {
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    ~UField() = default;
 
    // UObject interface.
    COREUOBJECT_API virtual void Serialize( FArchive& Ar ) override;
    COREUOBJECT_API virtual void PostLoad() override;
    COREUOBJECT_API virtual bool NeedsLoadForClient() const override;
    COREUOBJECT_API virtual bool NeedsLoadForServer() const override;
 
    // UField interface.
    COREUOBJECT_API virtual void AddCppProperty(FProperty* Property);
    COREUOBJECT_API virtual void Bind();
 
    COREUOBJECT_API UClass* GetOwnerClass() const;
 
    COREUOBJECT_API UStruct* GetOwnerStruct() const;
 
    COREUOBJECT_API FString GetAuthoredName() const;
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API FText GetDisplayNameText() const;
 
    COREUOBJECT_API FText GetToolTipText(bool bShortTooltip = false) const;
 
    static COREUOBJECT_API void FormatNativeToolTip(FString& ToolTipString, bool bRemoveExtraSections = true);
#endif // WITH_EDITORONLY_DATA
 
#if WITH_METADATA
    bool HasMetaData(const TCHAR* Key) const { return FindMetaData(Key) != nullptr; }
    bool HasMetaData(const FName& Key) const { return FindMetaData(Key) != nullptr; }
 
    COREUOBJECT_API const FString* FindMetaData(const TCHAR* Key) const;
    COREUOBJECT_API const FString* FindMetaData(const FName& Key) const;
 
    COREUOBJECT_API const FString& GetMetaData(const TCHAR* Key) const;
    COREUOBJECT_API const FString& GetMetaData(const FName& Key) const;
 
    COREUOBJECT_API FText GetMetaDataText(const TCHAR* MetaDataKey, const FTextKey LocalizationNamespace = FTextKey(), const FTextKey LocalizationKey = FTextKey()) const;
    COREUOBJECT_API FText GetMetaDataText(const FName& MetaDataKey, const FTextKey LocalizationNamespace = FTextKey(), const FTextKey LocalizationKey = FTextKey()) const;
 
    COREUOBJECT_API void SetMetaData(const TCHAR* Key, const TCHAR* InValue);
    COREUOBJECT_API void SetMetaData(const FName& Key, const TCHAR* InValue);
 
    bool GetBoolMetaData(const TCHAR* Key) const
    {       
        const FString& BoolString = GetMetaData(Key);
        // FString == operator does case insensitive comparison
        return (BoolString == "true");
    }
    bool GetBoolMetaData(const FName& Key) const
    {       
        const FString& BoolString = GetMetaData(Key);
        // FString == operator does case insensitive comparison
        return (BoolString == "true");
    }
 
    int32 GetIntMetaData(const TCHAR* Key) const
    {
        const FString& IntString = GetMetaData(Key);
        int32 Value = FCString::Atoi(*IntString);
        return Value;
    }
    int32 GetIntMetaData(const FName& Key) const
    {
        const FString& IntString = GetMetaData(Key);
        int32 Value = FCString::Atoi(*IntString);
        return Value;
    }
 
    float GetFloatMetaData(const TCHAR* Key) const
    {
        const FString& FloatString = GetMetaData(Key);
        float Value = FCString::Atof(*FloatString);
        return Value;
    }
    float GetFloatMetaData(const FName& Key) const
    {
        const FString& FloatString = GetMetaData(Key);
        float Value = FCString::Atof(*FloatString);
        return Value;
    }
    
    COREUOBJECT_API UClass* GetClassMetaData(const TCHAR* Key) const;
    COREUOBJECT_API UClass* GetClassMetaData(const FName& Key) const;
 
    COREUOBJECT_API void RemoveMetaData(const TCHAR* Key);
    COREUOBJECT_API void RemoveMetaData(const FName& Key);
#endif // WITH_METADATA
 
    COREUOBJECT_API bool HasAnyCastFlags(const uint64 InCastFlags) const;
    COREUOBJECT_API bool HasAllCastFlags(const uint64 InCastFlags) const;
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API virtual FField* GetAssociatedFField();
    COREUOBJECT_API virtual void SetAssociatedFField(FField* InField);
#endif // WITH_EDITORONLY_DATA
 
    using FLinkedListBuilder = TObjectPtrLinkedListBuilder<UField>;
};
 
#if WITH_EDITORONLY_DATA
enum class EPropertyValueFlags : uint8
{
    Initialized,
    Serialized,
};
#endif // WITH_EDITORONLY_DATA
 
class FStructBaseChain
{
#if USTRUCT_FAST_ISCHILDOF_IMPL == USTRUCT_ISCHILDOF_STRUCTARRAY
protected:
    FStructBaseChain() = default;
public:
    COREUOBJECT_API ~FStructBaseChain();
    UE_NONCOPYABLE(FStructBaseChain);
    
#if UE_WITH_CONSTINIT_UOBJECT
    consteval FStructBaseChain(TArrayView<const FStructBaseChain*> InBases)
        : StructBaseChainArray(InBases.GetData())
        , NumStructBasesInChainMinusOne(InBases.Num()-1)
    {
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    COREUOBJECT_API void ReinitializeBaseChainArray();
 
    [[nodiscard]] inline bool IsChildOfUsingStructArray(const FStructBaseChain& Parent) const
    {
        int32 NumParentStructBasesInChainMinusOne = Parent.NumStructBasesInChainMinusOne;
        return NumParentStructBasesInChainMinusOne <= NumStructBasesInChainMinusOne && StructBaseChainArray[NumParentStructBasesInChainMinusOne] == &Parent;
    }
 
private:
    const FStructBaseChain** StructBaseChainArray = nullptr;
    int32 NumStructBasesInChainMinusOne = -1;
 
    friend class UStruct;
#endif // USTRUCT_FAST_ISCHILDOF_IMPL == USTRUCT_ISCHILDOF_STRUCTARRAY
};
 
namespace UE::Private
{
consteval FStructBaseChain* AsStructBaseChain(UStruct* Struct);
 
template<typename... Classes>
struct TIntrinsicClassBaseChainImpl;
}
 
/*-----------------------------------------------------------------------------
    UStruct.
-----------------------------------------------------------------------------*/
enum class EStructStateFlags : uint16;
 
enum class EStructPropertyLinkFlags : uint8
{
    None = 0,
 
    LinkPostConstruct = 1 << 0,
 
    LinkDestructor = 1 << 1,
};
ENUM_CLASS_FLAGS(EStructPropertyLinkFlags)
 
 
PLATFORM_EMPTY_BASES // FStructBaseChain may be empty
UCLASS(MinimalAPI, Config = Engine)
class UStruct : public UField
#if CPP // UHT objects to FStructBaseChain not being public because it assumes it might be a UInterface
    , private FStructBaseChain
#endif
{
    GENERATED_BODY()
 
    // Variables.
protected:
    // For construction of intrinsic class GC schema 
    friend struct Z_Construct_UClass_UStruct_Statics;
    // For access to struct base chain from internal code
    friend consteval FStructBaseChain* UE::Private::AsStructBaseChain(UStruct*);
    // For access to struct base chain from possible non-internal intrinsic classes
    template<typename... Classes>
    friend struct UE::Private::TIntrinsicClassBaseChainImpl;
private:
    UPROPERTY(SkipSerialization)
    TObjectPtr<UStruct> SuperStruct;
 
public:
    UPROPERTY(SkipSerialization)
    TObjectPtr<UField> Children;
    
    FField* ChildProperties;
 
    int32 PropertiesSize;
    int16 MinAlignment;
 
private:
    std::atomic<uint16> StructStateFlags = 0;
 
public:
 
    union
    {
        TArray<uint8> Script = {};
#if UE_WITH_CONSTINIT_UOBJECT && WITH_METADATA
        TConstArrayView<UE::CodeGen::ConstInit::FMetaData> CompiledInMetaData;
#endif // UE_WITH_CONSTINIT_UOBJECT && WITH_METADATA
    };
 
    FProperty* PropertyLink;
    FProperty* RefLink;
    FProperty* DestructorLink;
    FProperty* PostConstructLink;
 
    UPROPERTY(SkipSerialization)
    TArray<TObjectPtr<UObject>> ScriptAndPropertyObjectReferences;
 
    typedef TArray<TPair<TFieldPath<FField>, int32>> FUnresolvedScriptPropertiesArray;
    FUnresolvedScriptPropertiesArray* UnresolvedScriptProperties;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(SkipSerialization)
    TArray<TObjectPtr<UPropertyWrapper>> PropertyWrappers;
    int32 FieldPathSerialNumber;
 
    UE_INTERNAL int32 TotalFieldCount = 0;
#endif // WITH_EDITORONLY_DATA
 
    mutable std::atomic<const struct FUnversionedStructSchema*> UnversionedGameSchema = nullptr;
#if WITH_EDITORONLY_DATA
    mutable std::atomic<const struct FUnversionedStructSchema*> UnversionedEditorSchema = nullptr;
 
    COREUOBJECT_API const FBlake3Hash& GetSchemaHash(bool bSkipEditorOnly) const;
 
protected:
    bool bHasAssetRegistrySearchableProperties;
#endif // WITH_EDITORONLY_DATA
 
public:
    using FSuperStructIterator = TObjectPtrLinkedListIterator<UStruct, &UStruct::SuperStruct, true>;
    using FConstSuperStructIterator = TObjectPtrLinkedListIteratorConst<UStruct, &UStruct::SuperStruct, true>;
 
    // Constructors.
    UStruct(const FObjectInitializer& ObjectInitializer) 
    : Super(ObjectInitializer)
    {
    }
    COREUOBJECT_API UStruct( EStaticConstructor, int32 InSize, int32 InAlignment, EObjectFlags InFlags );
    COREUOBJECT_API explicit UStruct(UStruct* InSuperStruct, SIZE_T ParamsSize = 0, SIZE_T Alignment = 0);
    COREUOBJECT_API explicit UStruct(const FObjectInitializer& ObjectInitializer, UStruct* InSuperStruct, SIZE_T ParamsSize = 0, SIZE_T Alignment = 0 );
    COREUOBJECT_API virtual ~UStruct();
#if UE_WITH_CONSTINIT_UOBJECT
    consteval UStruct(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams,
        UE::CodeGen::ConstInit::FStructParams StructParams
    )
        : Super(ObjectParams, FieldParams)
#if USTRUCT_FAST_ISCHILDOF_IMPL == USTRUCT_ISCHILDOF_STRUCTARRAY
        , FStructBaseChain(StructParams.BaseChain)
#endif
        , SuperStruct(StructParams.Super)
        , Children(StructParams.FirstChild)
        , ChildProperties(StructParams.ChildProperties)
        , PropertiesSize(StructParams.PropertiesSize)
        , MinAlignment(StructParams.MinAlignment)
#if WITH_METADATA
        , CompiledInMetaData(StructParams.MetaData)
#else
        , Script(ConstEval)
#endif
        , PropertyLink(nullptr)
        , RefLink(nullptr)
        , DestructorLink(nullptr)
        , PostConstructLink(nullptr)
        , ScriptAndPropertyObjectReferences(ConstEval)
        , UnresolvedScriptProperties(nullptr)
#if WITH_EDITORONLY_DATA
        , PropertyWrappers(ConstEval)
#endif
#if WITH_EDITORONLY_DATA
        , FieldPathSerialNumber(0)
        , bHasAssetRegistrySearchableProperties(false)
#endif
    {
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    // UObject interface.
    COREUOBJECT_API virtual void Serialize(FArchive& Ar) override;
    COREUOBJECT_API virtual void Serialize(FStructuredArchive::FRecord Record) override;
    COREUOBJECT_API virtual void PostLoad() override;
    COREUOBJECT_API virtual void FinishDestroy() override;
#if !UE_WITH_CONSTINIT_UOBJECT
    COREUOBJECT_API virtual void RegisterDependencies() override;
#endif // !UE_WITH_CONSTINIT_UOBJECT
    static COREUOBJECT_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    COREUOBJECT_API virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps) override;
    COREUOBJECT_API virtual void TagSubobjects(EObjectFlags NewFlags) override;
 
    // UField interface.
    COREUOBJECT_API virtual void AddCppProperty(FProperty* Property) override;
 
    COREUOBJECT_API FTopLevelAssetPath GetStructPathName() const;
 
    COREUOBJECT_API FProperty* FindPropertyByName(FName InName) const;
 
    UE_INTERNAL COREUOBJECT_API FProperty* FindPropertyByOffset(int32 Offset) const;
 
    COREUOBJECT_API void InstanceSubobjectTemplates(TNotNull<void*> Data, const void* DefaultData, const UStruct* DefaultStruct, TNotNull<UObject*> Owner, FObjectInstancingGraph* InstanceGraph);
 
    virtual UStruct* GetInheritanceSuper() const {return GetSuperStruct();}
 
    COREUOBJECT_API void StaticLink(bool bRelinkExistingProperties = false);
 
    COREUOBJECT_API virtual void Link(FArchive& Ar, bool bRelinkExistingProperties);
 
    virtual void SerializeBin(FArchive& Ar, void* Data) const final 
    {
        SerializeBin(FStructuredArchiveFromArchive(Ar).GetSlot(), Data);
    }
 
    COREUOBJECT_API virtual void SerializeBin(FStructuredArchive::FSlot Slot, void* Data) const;
 
    COREUOBJECT_API void SerializeBinEx( FStructuredArchive::FSlot Slot, void* Data, void const* DefaultData, UStruct* DefaultStruct ) const;
 
    virtual void SerializeTaggedProperties(FArchive& Ar, uint8* Data, const UStruct* DefaultsStruct, const uint8* Defaults, const UObject* BreakRecursionIfFullyLoad = nullptr) const final 
    {
        SerializeTaggedProperties(FStructuredArchiveFromArchive(Ar).GetSlot(), Data, DefaultsStruct, Defaults, BreakRecursionIfFullyLoad);
    }
 
    COREUOBJECT_API virtual void SerializeTaggedProperties(FStructuredArchive::FSlot Slot, uint8* Data, const UStruct* DefaultsStruct, const uint8* Defaults, const UObject* BreakRecursionIfFullyLoad = nullptr) const;
 
    COREUOBJECT_API virtual void PreloadChildren(FArchive& Ar);
 
    COREUOBJECT_API virtual void InitializeStruct(void* Dest, int32 ArrayDim = 1) const;
    
    COREUOBJECT_API virtual void DestroyStruct(void* Dest, int32 ArrayDim = 1) const;
 
#if DO_CHECK
    bool DebugIsPropertyChainReady() const;
#endif
 
    virtual FProperty* CustomFindProperty(const FName InName) const { return nullptr; };
 
    COREUOBJECT_API virtual EExprToken SerializeExpr(int32& iCode, FArchive& Ar);
 
    virtual const TCHAR* GetPrefixCPP() const { return TEXT("F"); }
 
    UE_FORCEINLINE_HINT int32 GetPropertiesSize() const
    {
        return PropertiesSize;
    }
 
    UE_FORCEINLINE_HINT int32 GetMinAlignment() const
    {
        return MinAlignment;
    }
 
    UE_FORCEINLINE_HINT int32 GetStructureSize() const
    {
        return Align(PropertiesSize,MinAlignment);
    }
 
    void SetPropertiesSize( int32 NewSize )
    {
        PropertiesSize = NewSize;
    }
 
    template<class T>
    bool IsChildOf() const
    {
        if constexpr (TModels_V<CStaticClassProvider, T>)
        {
            return IsChildOf(T::StaticClass());
        }
        else if constexpr (TModels_V<CStaticStructProvider, T>)
        {
            return IsChildOf(T::StaticStruct());
        }
        else
        {
            static_assert(sizeof(T) == 0, "Unsupported type - requires StaticClass or StaticStruct.");
            return false;
        }
    }
 
#if USTRUCT_FAST_ISCHILDOF_COMPARE_WITH_OUTERWALK || USTRUCT_FAST_ISCHILDOF_IMPL == USTRUCT_ISCHILDOF_OUTERWALK
    COREUOBJECT_API bool IsChildOf( const UStruct* SomeBase ) const;
#else
    bool IsChildOf(const UStruct* SomeBase) const
    {
        return (SomeBase ? IsChildOfUsingStructArray(*SomeBase) : false);
    }
#endif
 
    FSuperStructIterator GetSuperStructIterator()
    {
        return FSuperStructIterator(this);
    }
    FConstSuperStructIterator GetSuperStructIterator() const
    {
        return FConstSuperStructIterator(this);
    }
 
    UStruct* GetSuperStruct() const
    {
        return SuperStruct;
    }
 
    COREUOBJECT_API virtual void SetSuperStruct(UStruct* NewSuperStruct);
 
    COREUOBJECT_API virtual FString GetAuthoredNameForField(const UField* Field) const;
 
    COREUOBJECT_API virtual FString GetAuthoredNameForField(const FField* Field) const;
 
    virtual bool IsStructTrashed() const
    {
        return false;
    }
 
    COREUOBJECT_API void DestroyChildPropertiesAndResetPropertyLinks();
 
#if WITH_METADATA
    COREUOBJECT_API bool GetBoolMetaDataHierarchical(const FName& Key) const;
 
    COREUOBJECT_API bool GetStringMetaDataHierarchical(const FName& Key, FString* OutValue = nullptr) const;
 
    COREUOBJECT_API const UStruct* HasMetaDataHierarchical(const FName& Key) const;
#endif // WITH_METADATA
 
#if WITH_EDITORONLY_DATA
    UE_INTERNAL COREUOBJECT_API virtual bool ActivateTrackingPropertyValueFlag(EPropertyValueFlags Flags, void* Data) const;
 
    UE_INTERNAL COREUOBJECT_API virtual bool IsTrackingPropertyValueFlag(EPropertyValueFlags Flags, const void* Data) const;
 
    UE_INTERNAL COREUOBJECT_API virtual bool HasPropertyValueFlag(EPropertyValueFlags Flags, const void* Data, const FProperty* Property, int32 ArrayIndex = 0) const;
 
    UE_INTERNAL COREUOBJECT_API virtual void SetPropertyValueFlag(EPropertyValueFlags Flags, bool bValue, void* Data, const FProperty* Property, int32 ArrayIndex = 0) const;
 
    UE_INTERNAL COREUOBJECT_API virtual void ResetPropertyValueFlags(EPropertyValueFlags Flags, void* Data) const;
 
    UE_INTERNAL COREUOBJECT_API virtual void SerializePropertyValueFlags(EPropertyValueFlags Flags, void* Data, FStructuredArchiveRecord Record, FArchiveFieldName Name) const;
 
    UE_INTERNAL COREUOBJECT_API virtual void TrackDefaultInitializedProperties(void* DefaultData) const;
 
    /* Returns true if this struct has Asset Registry searchable properties */
    UE_FORCEINLINE_HINT bool HasAssetRegistrySearchableProperties() const
    {
        return bHasAssetRegistrySearchableProperties;
    }
#endif // WITH_EDITORONLY_DATA
 
    void SetUnresolvedScriptProperties(FUnresolvedScriptPropertiesArray& InUnresolvedProperties)
    {
        if (!UnresolvedScriptProperties)
        {
            UnresolvedScriptProperties = new FUnresolvedScriptPropertiesArray();
        }
        *UnresolvedScriptProperties = MoveTemp(InUnresolvedProperties);
    }
 
    inline void DeleteUnresolvedScriptProperties()
    {
        if (UnresolvedScriptProperties)
        {
            delete UnresolvedScriptProperties;
            UnresolvedScriptProperties = nullptr;
        }
    }
 
    COREUOBJECT_API void CollectBytecodeReferencedObjects(TArray<UObject*>& OutReferencedObjects);
    COREUOBJECT_API void CollectPropertyReferencedObjects(TArray<UObject*>& OutReferencedObjects);
    COREUOBJECT_API void CollectBytecodeAndPropertyReferencedObjects();
    COREUOBJECT_API void CollectBytecodeAndPropertyReferencedObjectsRecursively();
 
    UE_DEPRECATED(5.7, "Visit is deprecated, please use Visit with context instead.")
    COREUOBJECT_API EPropertyVisitorControlFlow Visit(void* Data, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorPath& /*Path*/, const FPropertyVisitorData& /*Data*/)> InFunc) const;
 
    COREUOBJECT_API EPropertyVisitorControlFlow Visit(void* Data, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorContext& /*Context*/)> InFunc, FPropertyVisitorContext::EScope InScope = FPropertyVisitorContext::EScope::All) const;
 
    COREUOBJECT_API virtual EPropertyVisitorControlFlow Visit(FPropertyVisitorContext& Context, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorContext& /*Context*/)> InFunc) const;
 
    COREUOBJECT_API virtual void* ResolveVisitedPathInfo(void* Data, const FPropertyVisitorInfo& Info) const;
 
protected:
 
    virtual FName FindPropertyNameFromGuid(const FGuid& PropertyGuid) const { return NAME_None; }
 
    virtual FGuid FindPropertyGuidFromName(const FName InName) const { return FGuid(); }
 
    virtual bool ArePropertyGuidsAvailable() const { return false; }
 
    COREUOBJECT_API void SerializeProperties(FArchive& Ar);
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API void ConvertUFieldsToFFields();
#endif // WITH_EDITORONLY_DATA
 
    COREUOBJECT_API void LoadTaggedPropertiesFromText(FStructuredArchive::FSlot Slot, uint8* Data, const UStruct* DefaultsStruct, const uint8* Defaults, const UObject* BreakRecursionIfFullyLoad) const;
 
private:
#if USTRUCT_FAST_ISCHILDOF_IMPL == USTRUCT_ISCHILDOF_STRUCTARRAY
    // For UObjectBaseUtility
    friend class UObjectBaseUtility;
    using FStructBaseChain::IsChildOfUsingStructArray;
    using FStructBaseChain::ReinitializeBaseChainArray;
 
    friend class FStructBaseChain;
    friend class FBlueprintCompileReinstancer;
#endif
 
    bool HasAllStructStateFlags(EStructStateFlags TestStructStateFlags) const;
 
    void SerializeVersionedTaggedProperties(FStructuredArchive::FSlot Slot, uint8* Data, const UStruct* DefaultsStruct, const uint8* Defaults, const UObject* BreakRecursionIfFullyLoad) const;
};
 
#if UE_WITH_CONSTINIT_UOBJECT
// Private access to protected base class for UHT generated code
UE_INTERNAL inline consteval FStructBaseChain* UE::Private::AsStructBaseChain(UStruct* Struct)
{
    return Struct;
}
#endif // UE_WITH_CONSTINIT_UOBJECT
 
enum EStructFlags
{
    // State flags.
    STRUCT_NoFlags              = 0x00000000,   
    STRUCT_Native               = 0x00000001,
 
    STRUCT_IdenticalNative      = 0x00000002,
    
    STRUCT_HasInstancedReference= 0x00000004,
 
    STRUCT_NoExport             = 0x00000008,
 
    STRUCT_Atomic               = 0x00000010,
 
    STRUCT_Immutable            = 0x00000020,
 
    STRUCT_AddStructReferencedObjects = 0x00000040,
 
    STRUCT_RequiredAPI          = 0x00000200,   
 
    STRUCT_NetSerializeNative   = 0x00000400,   
 
    STRUCT_SerializeNative      = 0x00000800,   
 
    STRUCT_CopyNative           = 0x00001000,   
 
    STRUCT_IsPlainOldData       = 0x00002000,   
 
    STRUCT_NoDestructor         = 0x00004000,   
 
    STRUCT_ZeroConstructor      = 0x00008000,   
 
    STRUCT_ExportTextItemNative = 0x00010000,   
 
    STRUCT_ImportTextItemNative = 0x00020000,   
 
    STRUCT_PostSerializeNative  = 0x00040000,
 
    STRUCT_SerializeFromMismatchedTag = 0x00080000,
 
    STRUCT_NetDeltaSerializeNative = 0x00100000,
 
    STRUCT_PostScriptConstruct     = 0x00200000,
 
    STRUCT_NetSharedSerialization = 0x00400000,
 
    STRUCT_Trashed = 0x00800000,
 
    STRUCT_NewerVersionExists = 0x01000000,
 
    STRUCT_CanEditChange = 0x02000000,
 
    STRUCT_Visitor = 0x04000000,
    
    STRUCT_Inherit              = STRUCT_HasInstancedReference|STRUCT_Atomic,
 
    STRUCT_ComputedFlags        = STRUCT_NetDeltaSerializeNative | STRUCT_NetSerializeNative | STRUCT_SerializeNative | STRUCT_PostSerializeNative | STRUCT_CopyNative | STRUCT_IsPlainOldData | STRUCT_NoDestructor | STRUCT_ZeroConstructor | STRUCT_IdenticalNative | STRUCT_AddStructReferencedObjects | STRUCT_ExportTextItemNative | STRUCT_ImportTextItemNative | STRUCT_SerializeFromMismatchedTag | STRUCT_PostScriptConstruct | STRUCT_NetSharedSerialization
};
 
 
 
#if CHECK_PUREVIRTUALS
#define DISABLE_ABSTRACT_CONSTRUCT TStructOpsTypeTraits<CPPSTRUCT>::WithPureVirtual
#else
#define DISABLE_ABSTRACT_CONSTRUCT (false && TStructOpsTypeTraits<CPPSTRUCT>::WithPureVirtual)
#endif
 
 
    template<class CPPSTRUCT>
    inline void AddStructReferencedObjectsOrNot(void* A, FReferenceCollector& Collector)
    {
        if constexpr (TStructOpsTypeTraits<CPPSTRUCT>::WithAddStructReferencedObjects)
        {
            ((CPPSTRUCT*)A)->AddStructReferencedObjects(Collector);
        }
    }
 
namespace UE::CodeGen::ConstInit
{
    struct FScriptStructParams;
}
 
namespace UE::CoreUObject::Private
{
    struct FCapabilities
    {
        EPropertyFlags ComputedPropertyFlags;
        EPropertyObjectReferenceType HasSerializerObjectReferences;
        bool HasNoopConstructor : 1;
        bool HasZeroConstructor : 1;
        bool HasDestructor : 1;
        bool HasSerializer : 1;
        bool HasStructuredSerializer : 1;
        bool HasPostSerialize : 1;
        bool HasNetSerializer : 1;
        bool HasNetSharedSerialization : 1;
        bool HasNetDeltaSerializer : 1;
        bool HasPostScriptConstruct : 1;
        bool IsPlainOldData : 1;
        bool IsUECoreType : 1;
        bool IsUECoreVariant : 1;
        bool HasCopy : 1;
        bool HasIdentical : 1;
        bool HasExportTextItem : 1;
        bool HasImportTextItem : 1;
        bool HasAddStructReferencedObjects : 1;
        bool HasSerializeFromMismatchedTag : 1;
        bool HasStructuredSerializeFromMismatchedTag : 1;
        bool HasGetTypeHash : 1;
        bool HasIntrusiveUnsetOptionalState : 1;
        bool IsAbstract : 1;
        bool HasFindInnerPropertyInstance : 1;
        bool ClearOnFinishDestroy : 1;
#if WITH_EDITOR
        bool HasCanEditChange : 1;
#endif
        bool HasVisitor : 1;
        bool HasGetPreloadDependencies : 1;
        bool IsIntrusiveOptionalSafeForGC : 1;
    };
 
    template <typename CppStruct>
    constexpr FCapabilities GetCapabilities()
    {
        using TraitsType = TStructOpsTypeTraits<CppStruct>;
 
        constexpr FCapabilities Capabilities {
            .ComputedPropertyFlags =
                (TIsPODType<CppStruct>::Value ? CPF_IsPlainOldData : CPF_None) |
                (std::is_trivially_destructible_v<CppStruct> ? CPF_NoDestructor : CPF_None) |
                (TIsZeroConstructType<CppStruct>::Value ? CPF_ZeroConstructor : CPF_None) |
                (TModels_V<CGetTypeHashable, CppStruct> ? CPF_HasGetValueTypeHash : CPF_None),
            .HasSerializerObjectReferences              = TraitsType::WithSerializerObjectReferences,
            .HasNoopConstructor                         = TraitsType::WithNoInitConstructor,
            .HasZeroConstructor                         = TraitsType::WithZeroConstructor,
            .HasDestructor                              = !(TraitsType::WithNoDestructor || TIsPODType<CppStruct>::Value),
            .HasSerializer                              = TraitsType::WithSerializer,
            .HasStructuredSerializer                    = TraitsType::WithStructuredSerializer,
            .HasPostSerialize                           = TraitsType::WithPostSerialize,
            .HasNetSerializer                           = TraitsType::WithNetSerializer,
            .HasNetSharedSerialization                  = TraitsType::WithNetSharedSerialization,
            .HasNetDeltaSerializer                      = TraitsType::WithNetDeltaSerializer,
            .HasPostScriptConstruct                     = TraitsType::WithPostScriptConstruct,
            .IsPlainOldData                             = TIsPODType<CppStruct>::Value,
            .IsUECoreType                               = TIsUECoreType<CppStruct>::Value,
            .IsUECoreVariant                            = TIsUECoreVariant<CppStruct>::Value,
            .HasCopy                                    = TraitsType::WithCopy,
            .HasIdentical                               = TraitsType::WithIdentical || TraitsType::WithIdenticalViaEquality,
            .HasExportTextItem                          = TraitsType::WithExportTextItem,
            .HasImportTextItem                          = TraitsType::WithImportTextItem,
            .HasAddStructReferencedObjects              = TraitsType::WithAddStructReferencedObjects,
            .HasSerializeFromMismatchedTag              = TraitsType::WithSerializeFromMismatchedTag,
            .HasStructuredSerializeFromMismatchedTag    = TraitsType::WithStructuredSerializeFromMismatchedTag,
            .HasGetTypeHash                             = TModels_V<CGetTypeHashable, CppStruct>,
            .HasIntrusiveUnsetOptionalState             = ::HasIntrusiveUnsetOptionalState<CppStruct>(),
            .IsAbstract                                 = TIsAbstract<CppStruct>::Value,
            .HasFindInnerPropertyInstance               = TraitsType::WithFindInnerPropertyInstance,
            .ClearOnFinishDestroy                       = TraitsType::WithClearOnFinishDestroy,
#if WITH_EDITOR
            .HasCanEditChange                           = TraitsType::WithCanEditChange,
#endif
            .HasVisitor                                 = TraitsType::WithVisitor,
            .HasGetPreloadDependencies                  = TraitsType::WithGetPreloadDependencies,
            .IsIntrusiveOptionalSafeForGC               = TraitsType::WithIntrusiveOptionalSafeForGC,
        };
        return Capabilities;
    }
 
    template <typename CppStruct>
        requires (!TStructOpsTypeTraits<CppStruct>::WithZeroConstructor)
    void Construct(void* Dest)
    {
        using TraitsType = TStructOpsTypeTraits<CppStruct>;
 
#if CHECK_PUREVIRTUALS
        if constexpr (!TraitsType::WithPureVirtual)
#endif
        {
            if constexpr (TraitsType::WithNoInitConstructor)
            {
                ::new (Dest) CppStruct(ForceInit);
            }
            else
            {
                ::new (Dest) CppStruct();
            }
        }
    }
 
#if !(UE_BUILD_TEST || UE_BUILD_SHIPPING)
    template <typename CppStruct>
        requires (!TStructOpsTypeTraits<CppStruct>::WithZeroConstructor)
    void ConstructForTests(void* Dest)
    {
        using TraitsType = TStructOpsTypeTraits<CppStruct>;
 
#if CHECK_PUREVIRTUALS
        if constexpr (!TraitsType::WithPureVirtual)
#endif
        {
            if constexpr (TraitsType::WithNoInitConstructor)
            {
                ::new (Dest) CppStruct(ForceInit);
            }
            else
            {
                // NOTE: unlike regular "Construct", no value init here! (missing "()")
                ::new (Dest) CppStruct;
            }
        }
    }
#endif
 
    template <typename CppStruct>
        requires (!TStructOpsTypeTraits<CppStruct>::WithNoDestructor && !TIsPODType<CppStruct>::Value)
    void Destruct(void* Dest)
    {
        DestructItem((CppStruct*)Dest);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithSerializer)
    bool SerializeArchive(FArchive& Ar, void* Data, UStruct* DefaultsStruct, const void* Defaults)
    {
        if constexpr (TModels_V<CStructSerializableWithDefaults, CppStruct>)
        {
            return ((CppStruct*)Data)->Serialize(Ar, DefaultsStruct, Defaults);
        }
        else
        {
            return ((CppStruct*)Data)->Serialize(Ar);
        }
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithStructuredSerializer)
    bool SerializeSlot(FStructuredArchive::FSlot Slot, void* Data, UStruct* DefaultsStruct, const void* Defaults)
    {
        if constexpr (TModels_V<CStructStructuredSerializableWithDefaults, CppStruct>)
        {
            return ((CppStruct*)Data)->Serialize(Slot, DefaultsStruct, Defaults);
        }
        else
        {
            return ((CppStruct*)Data)->Serialize(Slot);
        }
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithPostSerialize)
    void PostSerialize(const FArchive& Ar, void *Data)
    {
        ((CppStruct*)Data)->PostSerialize(Ar);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithNetSerializer)
    bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess, void* Data)
    {
        return ((CppStruct*)Data)->NetSerialize(Ar, Map, bOutSuccess);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithNetDeltaSerializer)
    bool NetDeltaSerialize(FNetDeltaSerializeInfo& DeltaParms, void* Data)
    {
        return ((CppStruct*)Data)->NetDeltaSerialize(DeltaParms);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithPostScriptConstruct)
    void PostScriptConstruct(void* Data)
    {
        ((CppStruct*)Data)->PostScriptConstruct();
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithGetPreloadDependencies)
    void GetPreloadDependencies(void* Data, TArray<UObject*>& OutDeps)
    {
        ((CppStruct*)Data)->GetPreloadDependencies(OutDeps);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithCopy)
    bool Copy(void* Dest, void const* Src, int32 ArrayDim)
    {
        static_assert((!TIsPODType<CppStruct>::Value), "You probably don't want custom copy for a POD type.");
 
        CppStruct* TypedDest = (CppStruct*)Dest;
        const CppStruct* TypedSrc  = (const CppStruct*)Src;
 
        for (; ArrayDim; --ArrayDim)
        {
            *TypedDest++ = *TypedSrc++;
        }
        return true;
    }
 
    // If you get an overload resolution error here, it's likely you've specified both WithIdentical and WithIdenticalViaEquality
    // in your TStructOpsTypeTraits, which is not supported.
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithIdentical)
    bool Identical(const void* A, const void* B, uint32 PortFlags, bool& bOutResult)
    {
        bOutResult = ((const CppStruct*)A)->Identical((const CppStruct*)B, PortFlags);
        return true;
    }
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithIdenticalViaEquality)
    bool Identical(const void* A, const void* B, uint32 PortFlags, bool& bOutResult)
    {
        bOutResult = (*(const CppStruct*)A == *(const CppStruct*)B);
        return true;
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithExportTextItem)
    bool ExportTextItem(FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope)
    {
        if (DefaultValue)
        {
            return ((const CppStruct*)PropertyValue)->ExportTextItem(ValueStr, *(const CppStruct*)DefaultValue, Parent, PortFlags, ExportRootScope);
        }
        else
        {
            TTypeCompatibleBytes<CppStruct> TmpDefaultValue;
            FMemory::Memzero(TmpDefaultValue.GetTypedPtr(), sizeof(CppStruct));
            if constexpr (!GetCapabilities<CppStruct>().HasZeroConstructor)
            {
                Construct<CppStruct>(TmpDefaultValue.GetTypedPtr());
            }
 
            const bool bResult = ((const CppStruct*)PropertyValue)->ExportTextItem(ValueStr, *(const CppStruct*)TmpDefaultValue.GetTypedPtr(), Parent, PortFlags, ExportRootScope);
 
            if constexpr (GetCapabilities<CppStruct>().HasDestructor)
            {
                Destruct<CppStruct>(TmpDefaultValue.GetTypedPtr());
            }
 
            return bResult;
        }
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithImportTextItem)
    bool ImportTextItem(const TCHAR*& Buffer, void* Data, int32 PortFlags, UObject* OwnerObject, FOutputDevice* ErrorText)
    {
        return ((CppStruct*)Data)->ImportTextItem(Buffer, PortFlags, OwnerObject, ErrorText);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithFindInnerPropertyInstance)
    bool FindInnerPropertyInstance(FName PropertyName, const void* Data, const FProperty*& OutProp, const void*& OutData)
    {
        return ((CppStruct*)Data)->FindInnerPropertyInstance(PropertyName, OutProp, OutData);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithAddStructReferencedObjects)
    void (*AddStructReferencedObjects())(void* A, FReferenceCollector& Collector)
    {
        return &AddStructReferencedObjectsOrNot<CppStruct>;
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithSerializeFromMismatchedTag)
    bool SerializeFromMismatchedTag(FPropertyTag const& Tag, FArchive& Ar, void* Data)
    {
        if constexpr (TIsUECoreType<CppStruct>::Value)
        {
            // Custom version of SerializeFromMismatchedTag for core types, which don't have access to FPropertyTag.
            FName StructName;
            if (Tag.GetType().GetName() == NAME_StructProperty && Tag.GetType().GetParameterCount() >= 1)
            {
                StructName = Tag.GetType().GetParameterName(0);
            }
            return ((CppStruct*)Data)->SerializeFromMismatchedTag(StructName, Ar);
        }
        else
        {
            return ((CppStruct*)Data)->SerializeFromMismatchedTag(Tag, Ar);
        }
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithStructuredSerializeFromMismatchedTag)
    bool StructuredSerializeFromMismatchedTag(FPropertyTag const& Tag, FStructuredArchive::FSlot Slot, void* Data)
    {
        if constexpr (TIsUECoreType<CppStruct>::Value)
        {
            // Custom version of SerializeFromMismatchedTag for core types, which don't understand FPropertyTag.
            FName StructName;
            if (Tag.GetType().GetName() == NAME_StructProperty && Tag.GetType().GetParameterCount() >= 1)
            {
                StructName = Tag.GetType().GetParameterName(0);
            }
            return ((CppStruct*)Data)->SerializeFromMismatchedTag(StructName, Slot);
        }
        else
        {
            return ((CppStruct*)Data)->SerializeFromMismatchedTag(Tag, Slot);
        }
    }
 
    template <typename CppStruct>
        requires (TModels_V<CGetTypeHashable, CppStruct>)
    uint32 GetStructTypeHash(const void* Src)
    {
        return GetTypeHashHelper(*(const CppStruct*)Src);
    }
 
    template <typename CppStruct>
        requires (HasIntrusiveUnsetOptionalState<CppStruct>())
    void InitializeIntrusiveUnsetOptionalValue(void* Data)
    {
        new (Data) TOptional<CppStruct>();
    }
 
    template <typename CppStruct>
        requires (HasIntrusiveUnsetOptionalState<CppStruct>())
    bool IsIntrusiveOptionalValueSet(const void* Data)
    {
        return reinterpret_cast<const TOptional<CppStruct>*>(Data)->IsSet();
    }
 
    template <typename CppStruct>
        requires (HasIntrusiveUnsetOptionalState<CppStruct>())
    void ClearIntrusiveOptionalValue(void* Data)
    {
        reinterpret_cast<TOptional<CppStruct>*>(Data)->Reset();
    }
 
#if WITH_EDITOR
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithCanEditChange)
    bool CanEditChange(const FEditPropertyChain& PropertyChain, const void* Data)
    {
        return ((const CppStruct*)Data)->CanEditChange(PropertyChain);
    }
    #define UE_FOREACH_FAKE_VTABLE_FUNC_EDITOR_ONLY(...) __VA_ARGS__
#else
    #define UE_FOREACH_FAKE_VTABLE_FUNC_EDITOR_ONLY(...)
#endif // WITH_EDITOR
 
#if !(UE_BUILD_TEST || UE_BUILD_SHIPPING)
    #define UE_FOREACH_FAKE_VTABLE_FUNC_WITH_TESTS_ONLY(...) __VA_ARGS__
#else
    #define UE_FOREACH_FAKE_VTABLE_FUNC_WITH_TESTS_ONLY(...)
#endif
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithVisitor)
    EPropertyVisitorControlFlow Visit(FPropertyVisitorContext& Context, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorContext& Context)> InFunc)
    {
        CppStruct* Struct = (CppStruct*)Context.Data.PropertyData;
        return Struct->Visit(Context, InFunc);
    }
 
    template <typename CppStruct>
        requires (!!TStructOpsTypeTraits<CppStruct>::WithVisitor)
    void* ResolveVisitedPathInfo(void* Data, const FPropertyVisitorInfo& Info)
    {
        return ((CppStruct*)Data)->ResolveVisitedPathInfo(Info);
    }
 
    #define UE_FOREACH_FAKE_VTABLE_FUNC(IndexNameFunctype) \
        IndexNameFunctype(0,    Construct,                              void(void* Address)) \
        UE_FOREACH_FAKE_VTABLE_FUNC_WITH_TESTS_ONLY( \
        IndexNameFunctype(1,    ConstructForTests,                      void(void* Address)) \
        ) \
        IndexNameFunctype(2,    Destruct,                               void(void* Address)) \
        IndexNameFunctype(3,    SerializeArchive,                       bool(FArchive& Ar, void* Data, UStruct* DefaultsStruct, const void* Defaults)) \
        IndexNameFunctype(4,    SerializeSlot,                          bool(FStructuredArchive::FSlot Slot, void* Data, UStruct* DefaultsStruct, const void* Defaults)) \
        IndexNameFunctype(5,    PostSerialize,                          void(const FArchive& Ar, void* Data)) \
        IndexNameFunctype(6,    NetSerialize,                           bool(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess, void* Data)) \
        IndexNameFunctype(7,    NetDeltaSerialize,                      bool(FNetDeltaSerializeInfo& DeltaParms, void* Data)) \
        IndexNameFunctype(8,    PostScriptConstruct,                    void(void* Data)) \
        IndexNameFunctype(9,    GetPreloadDependencies,                 void(void* Data, TArray<UObject*>& OutDeps)) \
        IndexNameFunctype(10,   Copy,                                   bool(void* Dest, void const* Src, int32 ArrayDim)) \
        IndexNameFunctype(11,   Identical,                              bool(const void* A, const void* B, uint32 PortFlags, bool& bOutResult)) \
        IndexNameFunctype(12,   ExportTextItem,                         bool(FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope)) \
        IndexNameFunctype(13,   ImportTextItem,                         bool(const TCHAR*& Buffer, void* Data, int32 PortFlags, UObject* OwnerObject, FOutputDevice* ErrorText)) \
        IndexNameFunctype(14,   FindInnerPropertyInstance,              bool(FName PropertyName, const void* Data, const FProperty*& OutProp, const void*& OutData)) \
        IndexNameFunctype(15,   AddStructReferencedObjects,             void(*())(void* A, FReferenceCollector& Collector)) \
        IndexNameFunctype(16,   SerializeFromMismatchedTag,             bool(FPropertyTag const& Tag, FArchive& Ar, void* Data)) \
        IndexNameFunctype(17,   StructuredSerializeFromMismatchedTag,   bool(FPropertyTag const& Tag, FStructuredArchive::FSlot Slot, void* Data)) \
        IndexNameFunctype(18,   GetStructTypeHash,                      uint32(const void* Src)) \
        IndexNameFunctype(19,   InitializeIntrusiveUnsetOptionalValue,  void(void* Data)) \
        IndexNameFunctype(20,   IsIntrusiveOptionalValueSet,            bool(const void* Data)) \
        IndexNameFunctype(21,   ClearIntrusiveOptionalValue,            void(void* Data)) \
        UE_FOREACH_FAKE_VTABLE_FUNC_EDITOR_ONLY( \
        IndexNameFunctype(22,   CanEditChange,                          bool(const FEditPropertyChain& PropertyChain, const void* Data)) \
        ) \
        IndexNameFunctype(23,   Visit,                                  EPropertyVisitorControlFlow(FPropertyVisitorContext& Context, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorContext& Context)> InFunc)) \
        IndexNameFunctype(24,   ResolveVisitedPathInfo,                 void*(void* Data, const FPropertyVisitorInfo& Info))
 
    // These represent one function per optional function in the fake vtable.
    enum class EStructOpsFakeVTableFlags : uint32
    {
        None = 0,
 
        #define UE_VTABLE_ENUM(Index, Name, Functype) Name = 1u << Index,
        UE_FOREACH_FAKE_VTABLE_FUNC(UE_VTABLE_ENUM)
        #undef UE_VTABLE_ENUM
    };
    ENUM_CLASS_FLAGS(EStructOpsFakeVTableFlags)
 
    template <EStructOpsFakeVTableFlags Flag>
    struct THandlingFunctionType;
    template <typename CppStruct, EStructOpsFakeVTableFlags Flag>
    struct THandlingFunctionPtr;
 
    #define UE_VTABLE_FUNC(Index, Name, Functype) \
        template <> \
        struct THandlingFunctionType<EStructOpsFakeVTableFlags::Name> \
        { \
            using Type = Functype; \
        }; \
        template <typename CppStruct> \
        struct THandlingFunctionPtr<CppStruct, EStructOpsFakeVTableFlags::Name> \
        { \
            inline static constexpr TIdentity_T<Functype>* Value = &Name<CppStruct>; \
        };
    UE_FOREACH_FAKE_VTABLE_FUNC(UE_VTABLE_FUNC)
    #undef UE_VTABLE_FUNC
 
    template <typename CppStruct>
    constexpr EStructOpsFakeVTableFlags GetStructOpsFakeVTableFlags()
    {
        using TraitsType = TStructOpsTypeTraits<CppStruct>;
 
        EStructOpsFakeVTableFlags Result = EStructOpsFakeVTableFlags::None;
 
        #define UE_VTABLE_SETFLAG(Index, Name, Functype) \
            if constexpr (requires(TIdentity_T<Functype>*& PtrRef) { PtrRef = &Name<CppStruct>; }) /* assignment to RefPtr shouldn't be needed, but is a workaround for MSVC bug: https://developercommunity.microsoft.com/t/Compiler-fails-overload-resolution-when/10939568 */ \
            { \
                Result |= EStructOpsFakeVTableFlags::Name; \
            }
        UE_FOREACH_FAKE_VTABLE_FUNC(UE_VTABLE_SETFLAG)
        #undef UE_VTABLE_SETFLAG
 
        return Result;
    }
 
    struct FStructOpsFakeVTable
    {
        // These flags will indicate which functions are present in the HandlingFunctions array.
        EStructOpsFakeVTableFlags Flags;
 
        FCapabilities Capabilities;
 
// MSVC doesn't like zero-sized arrays in the middle of structs
#ifndef _MSC_VER
        // One function pointer will exist in this array for every corresponding flag in Flags.
        // The function pointer types will be different, depending on the required signature, and
        // will need to be cast to the right type before being called.
        void (*HandlingFunctions[0])();
#endif
 
        // Retrieves a handling func associated with a particular flag.
        template <EStructOpsFakeVTableFlags FuncFlag>
        UE_REWRITE auto GetHandlingFunc() const
        {
            // Ensure a single flag is passed
            static_assert(EnumNumSetFlags(FuncFlag) == 1);
 
#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable : 4191) // unsafe conversion from 'function pointer type A' to 'function pointer type B'
#endif
            return (typename THandlingFunctionType<FuncFlag>::Type*)this->GetHandlingFuncImpl(FuncFlag);
#ifdef _MSC_VER
    #pragma warning(pop)
#endif
        }
 
    private:
        void (*GetHandlingFuncImpl(EStructOpsFakeVTableFlags FuncFlag) const)()
        {
            // Ensure that the fake vtable actually contains an entry for the requested function
            check(!!(this->Flags & FuncFlag));
 
            // Mask off all higher flags
            uint32 StructFlagsInt = (uint32)this->Flags;
            StructFlagsInt &= (uint32)FuncFlag - 1;
 
            // The number of remaining flags will be the index of the function into the function table.
            // Hopefully this turns into a popcnt.
            uint32 Index = 0;
            while (StructFlagsInt != 0)
            {
                StructFlagsInt &= StructFlagsInt - 1;
                ++Index;
            }
 
#ifdef _MSC_VER
            // Ensure that the end of the struct is where the start of the function pointer array in TStructOpsFakeVTable will be.
            static_assert(alignof(FStructOpsFakeVTable) == alignof(void(*)()));
            return ((void(**)())(this + 1))[Index];
#else
            return this->HandlingFunctions[Index];
#endif
        }
    };
 
    template <auto... Funcs>
    struct TStructOpsFakeVTable : public FStructOpsFakeVTable 
    {
        TTuple<decltype(Funcs)...> Functions;
    };
 
    template <>
    struct TStructOpsFakeVTable<> : public FStructOpsFakeVTable 
    {
    };
 
    // This represents an array of function pointers to handling functions and a header describing the capabilities
    // of the struct. Only one pointer exists per handling function. The index of the handling function is the index
    // of the set bit in the capabilities.
    //
    // Example: a struct S containing HasDestructor and HasIdentical would be laid out like this in memory:
    //   ComputedPropertyFlags
    //   HasSerializerObjectReferences
    //   ...:                         false
    //   HasDestructor:               true
    //   ...:                         false
    //   HasIdentical:                true
    //   ...:                         false
    //   void(*HandlingFunctions[2]): { &Destruct<S>, &Identical<S> }
    //
    template <typename CppStruct, auto... Funcs>
    inline constexpr const TStructOpsFakeVTable<Funcs...> TStructOpsFakeVTableInstance = 
    {
        {
            GetStructOpsFakeVTableFlags<CppStruct>(),
            GetCapabilities<CppStruct>()
        },
        MakeTuple(Funcs...)
    };
    template <typename CppStruct>
    inline constexpr const TStructOpsFakeVTable<> TStructOpsFakeVTableInstance<CppStruct> = 
    {
        {
            GetStructOpsFakeVTableFlags<CppStruct>(),
            GetCapabilities<CppStruct>()
        }
    };
 
    template <typename CppStruct, EStructOpsFakeVTableFlags Flags, auto... Funcs>
    struct TStructOpsFakeVTableForTypeImpl : TStructOpsFakeVTableForTypeImpl<CppStruct, EnumRemoveLowestSetFlag(Flags), Funcs..., THandlingFunctionPtr<CppStruct, EnumLowestSetFlag(Flags)>::Value>
    {
    };
 
    template <typename CppStruct, auto... Funcs>
    struct TStructOpsFakeVTableForTypeImpl<CppStruct, EStructOpsFakeVTableFlags::None, Funcs...>
    {
        inline static constexpr const FStructOpsFakeVTable* Value = &TStructOpsFakeVTableInstance<CppStruct, Funcs...>;
    };
 
    template <typename CppStruct>
    using TStructOpsFakeVTableForType = TStructOpsFakeVTableForTypeImpl<CppStruct, GetStructOpsFakeVTableFlags<CppStruct>()>;
}
 
UCLASS(MinimalAPI, Config = Engine)
class UScriptStruct : public UStruct
{
    GENERATED_BODY()
public:
    struct ICppStructOps
    {
        using FCapabilities = UE::CoreUObject::Private::FCapabilities;
 
        const UE::CoreUObject::Private::FStructOpsFakeVTable* FakeVPtr;
 
        constexpr ICppStructOps(int32 InSize, int32 InAlignment)
            : Size(InSize)
            , Alignment(InAlignment)
        {
        }
 
        const FCapabilities& GetCapabilities() const
        {
            return FakeVPtr->Capabilities;
        }
 
        bool HasNoopConstructor() const
        {
            return GetCapabilities().HasNoopConstructor;
        }
 
        bool HasZeroConstructor() const
        {
            return GetCapabilities().HasZeroConstructor;
        }
 
        void Construct(void *Dest)
        {
            FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::Construct>()(Dest);
        }
 
#if !(UE_BUILD_TEST || UE_BUILD_SHIPPING)
        void ConstructForTests(void* Dest)
        {
            FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::ConstructForTests>()(Dest);
        }
#endif
 
        bool HasDestructor() const
        {
            return GetCapabilities().HasDestructor;
        }
 
        void Destruct(void *Dest)
        {
            FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::Destruct>()(Dest);
        }
 
        UE_FORCEINLINE_HINT int32 GetSize() const
        {
            return Size;
        }
 
        UE_FORCEINLINE_HINT int32 GetAlignment() const
        {
            return Alignment;
        }
 
        bool HasSerializer() const
        {
            return GetCapabilities().HasSerializer;
        }
 
        bool HasStructuredSerializer() const
        {
            return GetCapabilities().HasStructuredSerializer;
        }
 
        UE_DEPRECATED(5.6, "Use the overload of Serialize with defaults.")
        bool Serialize(FArchive& Ar, void* Data)
        {
            return Serialize(Ar, Data, nullptr, nullptr);
        }
 
        UE_DEPRECATED(5.6, "Use the overload of Serialize with defaults.")
        bool Serialize(FStructuredArchive::FSlot Slot, void* Data)
        {
            return Serialize(Slot, Data, nullptr, nullptr);
        }
 
        bool Serialize(FArchive& Ar, void* Data, UStruct* DefaultsStruct, const void* Defaults)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::SerializeArchive>()(Ar, Data, DefaultsStruct, Defaults);
        }
        bool Serialize(FStructuredArchive::FSlot Slot, void* Data, UStruct* DefaultsStruct, const void* Defaults)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::SerializeSlot>()(Slot, Data, DefaultsStruct, Defaults);
        }
 
        bool HasPostSerialize() const
        {
            return GetCapabilities().HasPostSerialize;
        }
 
        void PostSerialize(const FArchive& Ar, void *Data)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::PostSerialize>()(Ar, Data);
        }
 
        bool HasNetSerializer() const
        {
            return GetCapabilities().HasNetSerializer;
        }
        
        bool HasNetSharedSerialization() const
        {
            return GetCapabilities().HasNetSharedSerialization;
        }
 
        bool NetSerialize(FArchive& Ar, UPackageMap* Map, bool& bOutSuccess, void *Data)
        {
            return HasNetSerializer() && FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::NetSerialize>()(Ar, Map, bOutSuccess, Data);
        }
 
        bool HasNetDeltaSerializer() const
        {
            return GetCapabilities().HasNetDeltaSerializer;
        }
 
        bool NetDeltaSerialize(FNetDeltaSerializeInfo & DeltaParms, void *Data)
        {
            return HasNetDeltaSerializer() && FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::NetDeltaSerialize>()(DeltaParms, Data);
        }
 
        bool HasPostScriptConstruct() const
        {
            return GetCapabilities().HasPostScriptConstruct;
        }
 
        void PostScriptConstruct(void *Data)
        {
            FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::PostScriptConstruct>()(Data);
        }
 
        bool HasGetPreloadDependencies() const
        {
            return GetCapabilities().HasGetPreloadDependencies;
        }
 
        void GetPreloadDependencies(void* Data, TArray<UObject*>& OutDeps)
        {
            if (HasGetPreloadDependencies())
            {
                FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::GetPreloadDependencies>()(Data, OutDeps);
            }
        }
 
        bool IsPlainOldData() const
        {
            return GetCapabilities().IsPlainOldData;
        }
 
        bool IsUECoreType() const
        {
            return GetCapabilities().IsUECoreType;
        }
 
        bool IsUECoreVariant() const
        {
            return GetCapabilities().IsUECoreVariant;
        }
 
        bool HasCopy() const
        {
            return GetCapabilities().HasCopy;
        }
 
        bool Copy(void* Dest, void const* Src, int32 ArrayDim)
        {
            return HasCopy() && FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::Copy>()(Dest, Src, ArrayDim);
        }
 
        bool HasIdentical() const
        {
            return GetCapabilities().HasIdentical;
        }
 
        bool Identical(const void* A, const void* B, uint32 PortFlags, bool& bOutResult)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::Identical>()(A, B, PortFlags, bOutResult);
        }
 
        bool HasExportTextItem() const
        {
            return GetCapabilities().HasExportTextItem;
        }
 
        bool ExportTextItem(FString& ValueStr, const void* PropertyValue, const void* DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::ExportTextItem>()(ValueStr, PropertyValue, DefaultValue, Parent, PortFlags, ExportRootScope);
        }
 
        bool HasImportTextItem() const
        {
            return GetCapabilities().HasImportTextItem;
        }
 
        bool ImportTextItem(const TCHAR*& Buffer, void* Data, int32 PortFlags, UObject* OwnerObject, FOutputDevice* ErrorText)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::ImportTextItem>()(Buffer, Data, PortFlags, OwnerObject, ErrorText);
        }
 
        bool HasFindInnerPropertyInstance() const
        {
            return GetCapabilities().HasFindInnerPropertyInstance;
        }
 
        bool FindInnerPropertyInstance(FName PropertyName, const void* Data, const FProperty*& OutProp, const void*& OutData) const
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::FindInnerPropertyInstance>()(PropertyName, Data, OutProp, OutData);
        }
 
        bool HasAddStructReferencedObjects() const
        {
            return GetCapabilities().HasAddStructReferencedObjects;
        }
 
        bool HasSerializerObjectReferences(EPropertyObjectReferenceType Type) const
        {
            return EnumHasAnyFlags(GetCapabilities().HasSerializerObjectReferences, Type);
        }
 
        using PointerToAddStructReferencedObjectsType = void (*)(void* A, FReferenceCollector& Collector);
        using TPointerToAddStructReferencedObjects UE_DEPRECATED(5.7, "TPointerToAddStructReferencedObjects has been deprecated, please use PointerToAddStructReferencedObjectsType instead.") = PointerToAddStructReferencedObjectsType;
 
        PointerToAddStructReferencedObjectsType AddStructReferencedObjects()
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::AddStructReferencedObjects>()();
        }
 
        bool HasSerializeFromMismatchedTag() const
        {
            return GetCapabilities().HasSerializeFromMismatchedTag;
        }
 
        bool HasStructuredSerializeFromMismatchedTag() const
        {
            return GetCapabilities().HasStructuredSerializeFromMismatchedTag;
        }
 
        bool SerializeFromMismatchedTag(FPropertyTag const& Tag, FArchive& Ar, void *Data)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::SerializeFromMismatchedTag>()(Tag, Ar, Data);
        }
 
        bool StructuredSerializeFromMismatchedTag(FPropertyTag const& Tag, FStructuredArchive::FSlot Slot, void *Data)
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::StructuredSerializeFromMismatchedTag>()(Tag, Slot, Data);
        }
 
        bool HasGetTypeHash() const
        {
            return GetCapabilities().HasGetTypeHash;
        }
 
        uint32 GetStructTypeHash(const void* Src)
        {
            if (HasGetTypeHash())
            {
                return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::GetStructTypeHash>()(Src);
            }
            else
            {
                return 0;
            }
        }
 
        EPropertyFlags GetComputedPropertyFlags() const
        {
            return GetCapabilities().ComputedPropertyFlags;
        }
 
        bool IsAbstract() const
        {
            return GetCapabilities().IsAbstract;
        }
 
        bool HasClearOnFinishDestroy() const
        {
            return GetCapabilities().ClearOnFinishDestroy;
        }
 
        bool HasIntrusiveUnsetOptionalState() const 
        {
            return GetCapabilities().HasIntrusiveUnsetOptionalState;
        }
 
        void InitializeIntrusiveUnsetOptionalValue(void* Data) const
        {
            FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::InitializeIntrusiveUnsetOptionalValue>()(Data);
        }
 
        bool IsIntrusiveOptionalValueSet(const void* Data) const
        {
            return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::IsIntrusiveOptionalValueSet>()(Data);
        }
 
        void ClearIntrusiveOptionalValue(void* Data) const
        {
            FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::ClearIntrusiveOptionalValue>()(Data);
        }
 
        bool IsIntrusiveOptionalSafeForGC() const
        {
            return GetCapabilities().IsIntrusiveOptionalSafeForGC;
        }
 
#if WITH_EDITOR
        bool HasCanEditChange() const
        {
            return GetCapabilities().HasCanEditChange;
        }
 
        bool CanEditChange(const FEditPropertyChain& PropertyChain, const void* Data) const
        {
            return HasCanEditChange() && FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::CanEditChange>()(PropertyChain, Data);
        }
#endif
 
        bool HasVisitor() const
        {
            return GetCapabilities().HasVisitor;
        }
 
        EPropertyVisitorControlFlow Visit(FPropertyVisitorContext& Context, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorContext& Context)> InFunc) const
        {
            if (HasVisitor())
            {
                return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::Visit>()(Context, InFunc);
            }
            else
            {
                return EPropertyVisitorControlFlow::StepOver;
            }
        }
 
        void* ResolveVisitedPathInfo(void* Data, const FPropertyVisitorInfo& Info) const
        {
            if (HasVisitor())
            {
                return FakeVPtr->GetHandlingFunc<UE::CoreUObject::Private::EStructOpsFakeVTableFlags::ResolveVisitedPathInfo>()(Data, Info);
            }
            else
            {
                return nullptr;
            }
        }
 
    private:
        const int32 Size;
        const int32 Alignment;
    };
 
    template<class CPPSTRUCT>
    struct TCppStructOps final : public ICppStructOps
    {
        typedef TStructOpsTypeTraits<CPPSTRUCT> TTraits;
        constexpr TCppStructOps()
            : ICppStructOps(sizeof(CPPSTRUCT), alignof(CPPSTRUCT))
        {
            static_assert(!(TTraits::WithAddStructReferencedObjects && alignof(CPPSTRUCT) < alignof(UObject*)), "AddStructReferencedObjects() requires pointer alignment");
 
            FakeVPtr = UE::CoreUObject::Private::TStructOpsFakeVTableForType<CPPSTRUCT>::Value;
 
            // We need some guarantees that TCppStructOps can be deleted via a ICppStructOps, until we fix up uses of TCppStructOps
            static_assert(sizeof(TCppStructOps) == sizeof(ICppStructOps));
            static_assert(std::is_trivially_destructible_v<TCppStructOps>);
            static_assert(!std::is_polymorphic_v<TCppStructOps>);
        }
 
        static_assert(!(TTraits::WithSerializeFromMismatchedTag && TTraits::WithStructuredSerializeFromMismatchedTag), "Structs cannot have both WithSerializeFromMismatchedTag and WithStructuredSerializeFromMismatchedTag set");
    };
 
    template<class CPPSTRUCT>
    struct TAutoCppStructOps
    {
        TAutoCppStructOps(FTopLevelAssetPath InName)
        : Name(InName)
        {
            DeferCppStructOps(Name,new TCppStructOps<CPPSTRUCT>);
        }
 
        ~TAutoCppStructOps()
        {
            RemoveDeferredCppStructOps(Name);
        }
        FTopLevelAssetPath Name;
    };
    #define IMPLEMENT_STRUCT(BaseName) \
        UE_DEPRECATED_MACRO(5.1, "IMPLEMENT_STRUCT has been deprecated. Use UE_IMPLEMENT_STRUCT and provide struct package name as well as struct name") static UScriptStruct::TAutoCppStructOps<F##BaseName> BaseName##_Ops(FTopLevelAssetPath(TEXT("/Script/CoreUObject"), TEXT(#BaseName))); 
 
    #define UE_IMPLEMENT_STRUCT(PackageNameText, BaseName) \
        static UScriptStruct::TAutoCppStructOps<F##BaseName> BaseName##_Ops(FTopLevelAssetPath(TEXT(PackageNameText), TEXT(#BaseName))); 
 
    COREUOBJECT_API UScriptStruct( EStaticConstructor, int32 InSize, int32 InAlignment, EObjectFlags InFlags );
    COREUOBJECT_API explicit UScriptStruct(const FObjectInitializer& ObjectInitializer, UScriptStruct* InSuperStruct, ICppStructOps* InCppStructOps = nullptr, EStructFlags InStructFlags = STRUCT_NoFlags, SIZE_T ExplicitSize = 0, SIZE_T ExplicitAlignment = 0);
    COREUOBJECT_API explicit UScriptStruct(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
 
#if UE_WITH_CONSTINIT_UOBJECT
    consteval UScriptStruct(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams,
        UE::CodeGen::ConstInit::FStructParams StructParams,
        UE::CodeGen::ConstInit::FScriptStructParams Params
    );
#endif
 
public:
    EStructFlags StructFlags;
 
protected:
    bool bPrepareCppStructOpsCompleted;
    ICppStructOps* CppStructOps;
 
    COREUOBJECT_API FTopLevelAssetPath GetFlattenedStructPathName() const;
 
public:
 
    // UObject Interface
    virtual COREUOBJECT_API void Serialize(FArchive& Ar) override;
    virtual COREUOBJECT_API void Serialize(FStructuredArchive::FRecord Record) override;
 
    // UStruct interface.
    virtual COREUOBJECT_API void Link(FArchive& Ar, bool bRelinkExistingProperties) override;
    virtual COREUOBJECT_API void InitializeStruct(void* Dest, int32 ArrayDim = 1) const override;
    virtual COREUOBJECT_API void DestroyStruct(void* Dest, int32 ArrayDim = 1) const override;
    virtual COREUOBJECT_API bool IsStructTrashed() const override;
    // End of UStruct interface.
 
    void COREUOBJECT_API SetStructTrashed(bool bIsTrash);
 
    static COREUOBJECT_API void DeferCppStructOps(FTopLevelAssetPath Target, ICppStructOps* InCppStructOps);
 
    static COREUOBJECT_API void RemoveDeferredCppStructOps(FTopLevelAssetPath Target);
 
    static COREUOBJECT_API void RemoveAllDeferredCppStructOps(FName PackageName);
 
    template<class CPPSTRUCT>
    static void DeferCppStructOps(FTopLevelAssetPath Target)
    {
        if constexpr (DISABLE_ABSTRACT_CONSTRUCT)
        {
            DeferCppStructOps(Target, nullptr);
        }
        else
        {
            DeferCppStructOps(Target, new UScriptStruct::TCppStructOps<CPPSTRUCT>);
        }
    }
 
    virtual COREUOBJECT_API void PrepareCppStructOps();
 
    inline ICppStructOps* GetCppStructOps() const
    {
        checkf(bPrepareCppStructOpsCompleted, TEXT("GetCppStructOps: PrepareCppStructOps() has not been called for class %s"), *GetPathName());
        return CppStructOps;
    }
 
    void ClearCppStructOps()
    {
        StructFlags = EStructFlags(StructFlags & ~STRUCT_ComputedFlags);
        bPrepareCppStructOpsCompleted = false;
        CppStructOps = nullptr;
    }
 
    UE_FORCEINLINE_HINT bool HasDefaults() const
    {
        return !!GetCppStructOps();
    }
 
    bool ShouldSerializeAtomically(FArchive& Ar) const
    {
        if( (StructFlags&STRUCT_Atomic) != 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    bool UseNativeSerialization() const
    {
        if ((StructFlags&(STRUCT_SerializeNative)) != 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    COREUOBJECT_API bool UseBinarySerialization(const FArchive& Ar) const;
 
    COREUOBJECT_API void SerializeItem(FArchive& Ar, void* Value, void const* Defaults);
    COREUOBJECT_API void SerializeItem(FStructuredArchive::FSlot Slot, void* Value, void const* Defaults);
 
    COREUOBJECT_API void ExportText(FString& ValueStr, const void* Value, const void* Defaults, UObject* OwnerObject, int32 PortFlags, UObject* ExportRootScope, bool bAllowNativeOverride = true) const;
 
    COREUOBJECT_API const TCHAR* ImportText(const TCHAR* Buffer, void* Value, UObject* OwnerObject, int32 PortFlags, FOutputDevice* ErrorText, const FString& StructName, bool bAllowNativeOverride = true) const;
 
    COREUOBJECT_API const TCHAR* ImportText(const TCHAR* Buffer, void* Value, UObject* OwnerObject, int32 PortFlags, FOutputDevice* ErrorText, const TFunctionRef<FString()>& StructNameGetter, bool bAllowNativeOverride = true) const;
 
    COREUOBJECT_API bool CompareScriptStruct(const void* A, const void* B, uint32 PortFlags) const;
 
    COREUOBJECT_API void CopyScriptStruct(void* Dest, void const* Src, int32 ArrayDim = 1) const;
    
    COREUOBJECT_API void ClearScriptStruct(void* Dest, int32 ArrayDim = 1) const;
 
    virtual COREUOBJECT_API uint32 GetStructTypeHash(const void* Src) const;
 
    virtual COREUOBJECT_API void RecursivelyPreload();
 
    virtual COREUOBJECT_API FGuid GetCustomGuid() const;
    
    virtual COREUOBJECT_API FString GetStructCPPName(uint32 CPPExportFlags = 0) const;
 
    virtual COREUOBJECT_API void InitializeDefaultValue(uint8* InStructData) const;
    
    virtual COREUOBJECT_API bool FindInnerPropertyInstance(FName PropertyName, const void* Data, const FProperty*& OutProp, const void*& OutData) const;
 
    /* Custom visit implementation for structs */
    using Super::Visit;
    virtual COREUOBJECT_API EPropertyVisitorControlFlow Visit(FPropertyVisitorContext& Context, const TFunctionRef<EPropertyVisitorControlFlow(const FPropertyVisitorContext& /*Context*/)> InFunc) const override;
    virtual COREUOBJECT_API void* ResolveVisitedPathInfo(void* Data, const FPropertyVisitorInfo& Info) const override;
};
 
/*-----------------------------------------------------------------------------
    UFunction.
-----------------------------------------------------------------------------*/
 
//
// Reflection data for a replicated or Kismet callable function.
//
UCLASS(MinimalAPI, Within=Object, Config = Engine)
class UFunction : public UStruct
{
    GENERATED_BODY()
public:
    // Persistent variables.
 
    EFunctionFlags FunctionFlags;
 
    // Variables in memory only.
    
    uint8 NumParms;
    uint16 ParmsSize;
    uint16 ReturnValueOffset;
    uint16 RPCId;
    uint16 RPCResponseId;
 
    FProperty* FirstPropertyToInit;
 
#if UE_BLUEPRINT_EVENTGRAPH_FASTCALLS
    UFunction* EventGraphFunction;
 
    int32 EventGraphCallOffset;
#endif
 
#if WITH_LIVE_CODING
    UFunction** SingletonPtr;
#endif
 
private:
    FNativeFuncPtr Func;
 
public:
    UE_FORCEINLINE_HINT FNativeFuncPtr GetNativeFunc() const
    {
        return Func;
    }
 
    UE_FORCEINLINE_HINT void SetNativeFunc(FNativeFuncPtr InFunc)
    {
        Func = InFunc;
    }
 
    COREUOBJECT_API void Invoke(UObject* Obj, FFrame& Stack, RESULT_DECL);
 
    // Constructors.
    UFunction(const FObjectInitializer& ObjectInitializer) 
    : Super(ObjectInitializer)
    {
    }
    COREUOBJECT_API explicit UFunction(const FObjectInitializer& ObjectInitializer, UFunction* InSuperFunction, EFunctionFlags InFunctionFlags = FUNC_None, SIZE_T ParamsSize = 0 );
    COREUOBJECT_API explicit UFunction(UFunction* InSuperFunction, EFunctionFlags InFunctionFlags = FUNC_None, SIZE_T ParamsSize = 0);
 
#if UE_WITH_CONSTINIT_UOBJECT
    consteval UFunction(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams,
        UE::CodeGen::ConstInit::FStructParams StructParams,
        UE::CodeGen::ConstInit::FFunctionParams Params)
        : Super(ObjectParams, FieldParams, StructParams)
        , FunctionFlags(Params.FunctionFlags)
        , NumParms(0) 
        , ParmsSize(0) 
        , ReturnValueOffset(0) 
        , RPCId(Params.RPCId) 
        , RPCResponseId(Params.RPCResponseId) 
        , FirstPropertyToInit(nullptr) 
#if UE_BLUEPRINT_EVENTGRAPH_FASTCALLS
        , EventGraphFunction(nullptr) 
        , EventGraphCallOffset(INDEX_NONE)
#endif
        , Func(Params.NativeFunction) 
    {
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    COREUOBJECT_API void InitializeDerivedMembers();
 
    // UObject interface.
    COREUOBJECT_API virtual void Serialize( FArchive& Ar ) override;
    COREUOBJECT_API virtual void PostLoad() override;
 
    // UField interface.
    COREUOBJECT_API virtual void Bind() override;
 
    // UStruct interface.
    virtual UStruct* GetInheritanceSuper() const override { return nullptr;}
    COREUOBJECT_API virtual void Link(FArchive& Ar, bool bRelinkExistingProperties) override;
 
    UFunction* GetSuperFunction() const;
 
    COREUOBJECT_API FProperty* GetReturnProperty() const;
 
    UE_FORCEINLINE_HINT UClass* GetOuterUClass() const
    {
        UObject* Outer = GetOuter();
        if (Outer && Outer->IsA<UClass>())
        {
            return reinterpret_cast<UClass*>(Outer);
        }
        return nullptr;
    }
 
    UE_FORCEINLINE_HINT UClass* GetOuterUClassUnchecked() const
    {
        // declaration order mandates reinterpret_cast:
        return reinterpret_cast<UClass*>(GetOuter());
    }
 
    UE_FORCEINLINE_HINT bool HasAnyFunctionFlags( EFunctionFlags FlagsToCheck ) const
    {
        return (FunctionFlags&FlagsToCheck) != 0 || FlagsToCheck == FUNC_AllFlags;
    }
 
    UE_FORCEINLINE_HINT bool HasAllFunctionFlags( EFunctionFlags FlagsToCheck ) const
    {
        return ((FunctionFlags & FlagsToCheck) == FlagsToCheck);
    }
 
    inline static uint64 GetDefaultIgnoredSignatureCompatibilityFlags()
    {
        //@TODO: UCREMOVAL: CPF_ConstParm added as a hack to get blueprints compiling with a const DamageType parameter.
        const uint64 IgnoreFlags = CPF_PersistentInstance | CPF_ExportObject | CPF_InstancedReference 
            | CPF_ContainsInstancedReference | CPF_ComputedFlags | CPF_ConstParm | CPF_UObjectWrapper | CPF_TObjectPtr
            | CPF_NativeAccessSpecifiers | CPF_AdvancedDisplay | CPF_BlueprintVisible | CPF_BlueprintReadOnly;
        return IgnoreFlags;
    }
 
    COREUOBJECT_API bool IsSignatureCompatibleWith(const UFunction* OtherFunction) const;
 
    COREUOBJECT_API bool IsSignatureCompatibleWith(const UFunction* OtherFunction, uint64 IgnoreFlags) const;
};
 
//
// Function definition used by dynamic delegate declarations
//
UCLASS(MinimalAPI)
class UDelegateFunction : public UFunction
{
    GENERATED_BODY()
 
public:
    explicit UDelegateFunction(const FObjectInitializer& ObjectInitializer)
        : Super(ObjectInitializer)
    {
    }
    COREUOBJECT_API explicit UDelegateFunction(const FObjectInitializer& ObjectInitializer, UFunction* InSuperFunction, EFunctionFlags InFunctionFlags = FUNC_None, SIZE_T ParamsSize = 0);
    COREUOBJECT_API explicit UDelegateFunction(UFunction* InSuperFunction, EFunctionFlags InFunctionFlags = FUNC_None, SIZE_T ParamsSize = 0);
 
#if UE_WITH_CONSTINIT_UOBJECT
    consteval UDelegateFunction(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams,
        UE::CodeGen::ConstInit::FStructParams StructParams,
        UE::CodeGen::ConstInit::FFunctionParams Params
    )
        : Super(ObjectParams, FieldParams, StructParams, Params)
    {
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
};
 
//
// Function definition used by sparse dynamic delegate declarations
//
UCLASS(MinimalAPI)
class USparseDelegateFunction : public UDelegateFunction
{
    GENERATED_BODY()
 
public:
    explicit USparseDelegateFunction(const FObjectInitializer& ObjectInitializer)
        : Super(ObjectInitializer)
    {
    }
    COREUOBJECT_API explicit USparseDelegateFunction(const FObjectInitializer& ObjectInitializer, UFunction* InSuperFunction, EFunctionFlags InFunctionFlags = FUNC_None, SIZE_T ParamsSize = 0);
    COREUOBJECT_API explicit USparseDelegateFunction(UFunction* InSuperFunction, EFunctionFlags InFunctionFlags = FUNC_None, SIZE_T ParamsSize = 0);
 
#if UE_WITH_CONSTINIT_UOBJECT
    consteval USparseDelegateFunction(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams,
        UE::CodeGen::ConstInit::FStructParams StructParams,
        UE::CodeGen::ConstInit::FFunctionParams FunctionParams,
        UE::CodeGen::ConstInit::FSparseDelegateParams Params
    )
        : Super(ObjectParams, FieldParams, StructParams, FunctionParams)
        , CompiledInOwningClassName(Params.SparseOwningClassNameUTF8)
        , CompiledInDelegateName(Params.SparseDelegateNameUTF8)
    {
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    COREUOBJECT_API virtual void Serialize(FArchive& Ar) override;
 
    // CONSTINIT_UOBJECT_TODO: Size increase
    union
    {
        FName OwningClassName = {};
#if UE_WITH_CONSTINIT_UOBJECT
        const UTF8CHAR* CompiledInOwningClassName;
#endif // UE_WITH_CONSTINIT_UOBJECT
    };
    union
    { 
        FName DelegateName = {};
#if UE_WITH_CONSTINIT_UOBJECT
        const UTF8CHAR* CompiledInDelegateName;
#endif // UE_WITH_CONSTINIT_UOBJECT
    };
};
 
/*-----------------------------------------------------------------------------
    UEnum.
-----------------------------------------------------------------------------*/
 
typedef FText(*FEnumDisplayNameFn)(int32);
 
enum class EGetByNameFlags
{
    None = 0,
 
    ErrorIfNotFound     = 0x01,
 
    CaseSensitive       = 0x02,
 
    CheckAuthoredName   = 0x04,
};
 
ENUM_CLASS_FLAGS(EGetByNameFlags)
 
//
// Reflection data for an enumeration.
//
UCLASS(MinimalAPI, Config = Engine)
class UEnum : public UField
{
    GENERATED_BODY()
 
public:
    COREUOBJECT_API UEnum(const FObjectInitializer& ObjectInitialzer);
 
    enum class ECppForm : uint8
    {
        Regular,
        Namespaced,
        EnumClass
    };
 
#if UE_WITH_CONSTINIT_UOBJECT
    consteval UEnum(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams,
        UE::CodeGen::ConstInit::FEnumParams EnumParams
    )
        : Super(ObjectParams, FieldParams)
        , CppTypeStaticUTF8(EnumParams.CppTypeStaticUTF8)
        , Names(EnumParams.EnumValues.Num(), EnumParams.StaticNamesUTF8.GetData(), EnumParams.EnumValues.GetData())
        , CppForm((ECppForm)EnumParams.CppForm)
        , EnumFlags(EnumParams.EnumFlags)
        , EnumDisplayNameFn(EnumParams.DisplayNameFn)
    {
        check(EnumParams.StaticNamesUTF8.Num() == EnumParams.EnumValues.Num());
    }
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    union 
    { 
        FString CppType = {};       
#if UE_WITH_CONSTINIT_UOBJECT
        const UTF8CHAR* CppTypeStaticUTF8;
#endif // UE_WITH_CONSTINIT_UOBJECT
    };
 
#if WITH_METADATA && UE_WITH_CONSTINIT_UOBJECT
    // Nothing to alias with here to save space, but builds with metadata enabled are less space constrained
    TConstArrayView<UE::CodeGen::ConstInit::FMetaData> CompiledInMetaData;
#endif // WITH_METADATA && UE_WITH_CONSTINIT_UOBJECT
 
    // Index is the internal index into the Enum array, and is not useful outside of the Enum system
    // Value is the value set in the Enum Class in C++ or Blueprint
    // Enums can be sparse, which means that not every valid Index is a proper Value, and they are not necessarily equal
    // It is not safe to cast an Index to a Enum Class, always do that with a Value instead
 
    inline int32 GetIndexByValue(int64 InValue) const
    {
        for (int32 i = 0; i < Names.Num(); ++i)
        {
            if (Names[i].Value == InValue)
            {
                return i;
            }
        }
        return INDEX_NONE;
    }
 
    inline int64 GetValueByIndex(int32 Index) const
    {
        check(Names.IsValidIndex(Index));
        return Names[Index].Value;
    }
 
    COREUOBJECT_API FName GetNameByIndex(int32 Index) const;
 
    COREUOBJECT_API int32 GetIndexByName(FName InName, EGetByNameFlags Flags = EGetByNameFlags::None) const;
 
    COREUOBJECT_API FName GetNameByValue(int64 InValue) const;
 
    COREUOBJECT_API int64 GetValueByName(FName InName, EGetByNameFlags Flags = EGetByNameFlags::None) const;
 
    COREUOBJECT_API int64 GetValueOrBitfieldFromString(FStringView InString, EGetByNameFlags LookupFlags = EGetByNameFlags::None) const;
 
    COREUOBJECT_API FString GetNameStringByIndex(int32 InIndex) const;
 
    COREUOBJECT_API int32 GetIndexByNameString(const FString& SearchString, EGetByNameFlags Flags = EGetByNameFlags::None) const;
 
    COREUOBJECT_API FString GetNameStringByValue(int64 InValue) const;
 
    COREUOBJECT_API FString GetValueOrBitfieldAsString(int64 InValue) const;
 
    COREUOBJECT_API FString GetValueOrBitfieldAsAuthoredNameString(int64 InValue) const;
 
    COREUOBJECT_API FText GetValueOrBitfieldAsDisplayNameText(int64 InValue) const;
 
    COREUOBJECT_API bool FindNameStringByValue(FString& Out, int64 InValue) const;
 
    COREUOBJECT_API int64 GetValueByNameString(const FString& SearchString, EGetByNameFlags Flags = EGetByNameFlags::None) const;
 
    COREUOBJECT_API virtual FText GetDisplayNameTextByIndex(int32 InIndex) const;
 
    COREUOBJECT_API FText GetDisplayNameTextByValue(int64 InValue) const;
 
    COREUOBJECT_API bool FindDisplayNameTextByValue(FText& Out, int64 InValue) const;
 
    COREUOBJECT_API virtual FString GetAuthoredNameStringByIndex(int32 InIndex) const;
 
    COREUOBJECT_API FString GetAuthoredNameStringByValue(int64 InValue) const;
 
    COREUOBJECT_API bool FindAuthoredNameStringByValue(FString& Out, int64 InValue) const;
 
    COREUOBJECT_API int64 GetMaxEnumValue() const;
 
    COREUOBJECT_API bool IsValidEnumValue(int64 InValue) const;
 
    COREUOBJECT_API bool IsValidEnumValueOrBitfield(int64 InValue) const;
 
    COREUOBJECT_API bool IsValidEnumName(FName InName) const;
 
    UE_DEPRECATED(5.1, "RemoveNamesFromMasterList is deprecated, please use RemoveNamesFromPrimaryList instead.")
    void RemoveNamesFromMasterList()
    {
        RemoveNamesFromPrimaryList();
    }
 
    COREUOBJECT_API void RemoveNamesFromPrimaryList();
 
    COREUOBJECT_API virtual int64 ResolveEnumerator(FArchive& Ar, int64 EnumeratorIndex) const;
 
    void SetEnumDisplayNameFn(FEnumDisplayNameFn InEnumDisplayNameFn)
    {
        EnumDisplayNameFn = InEnumDisplayNameFn;
    }
 
    ECppForm GetCppForm() const
    {
        return CppForm;
    }
 
    void SetEnumFlags(EEnumFlags FlagsToSet)
    {
        EnumFlags |= FlagsToSet;
    }
 
    bool HasAnyEnumFlags(EEnumFlags InFlags) const
    {
        return EnumHasAnyFlags(EnumFlags, InFlags);
    }
 
    static bool IsFullEnumName(const TCHAR* InEnumName)
    {
        return !!FCString::Strstr(InEnumName, TEXT("::"));
    }
 
    COREUOBJECT_API virtual FString GenerateFullEnumName(const TCHAR* InEnumName) const;
 
    COREUOBJECT_API static int64 LookupEnumName(FName PackageName, FName TestName, EFindFirstObjectOptions Options = EFindFirstObjectOptions::None, UEnum** OutFoundEnum = nullptr);
 
    UE_DEPRECATED(5.1, "LookupEnumName that takes only enum name is deprecated. Please use the version of this function that also takes enum package name.")
    static int64 LookupEnumName(FName TestName, UEnum** FoundEnum = nullptr)
    {
        return LookupEnumName(FName(), TestName, EFindFirstObjectOptions::None, FoundEnum);
    }
 
    COREUOBJECT_API static int64 LookupEnumNameSlow(FName PackageName, const TCHAR* InTestShortName, EFindFirstObjectOptions Options = EFindFirstObjectOptions::None, UEnum** OutFoundEnum = nullptr);
 
    UE_DEPRECATED(5.1, "LookupEnumNameSlow that takes only enum name is deprecated. Please use the version of this function that also takes enum package name.")
    static int64 LookupEnumNameSlow(const TCHAR* InTestShortName, UEnum** FoundEnum = nullptr)
    {
        return LookupEnumNameSlow(FName(), InTestShortName, EFindFirstObjectOptions::None, FoundEnum);
    }
 
    COREUOBJECT_API static int64 ParseEnum(const TCHAR*& Str);
 
    COREUOBJECT_API bool ContainsExistingMax() const;
 
    COREUOBJECT_API virtual bool SetEnums(TArray<TPair<FName, int64>>& InNames, ECppForm InCppForm, EEnumFlags InFlags = EEnumFlags::None, bool bAddMaxKeyIfMissing = true);
 
#if UE_WITH_CONSTINIT_UOBJECT
    COREUOBJECT_API void InitializeNames();
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    int32 NumEnums() const
    {
        return Names.Num();
    }
 
    COREUOBJECT_API FString GenerateEnumPrefix() const;
 
    COREUOBJECT_API static FString GenerateEnumPrefix(const TArray<TPair<FName, int64>>& InNames, FName InEnumName);
 
#if WITH_EDITOR
    COREUOBJECT_API FText GetToolTipTextByIndex(int32 NameIndex) const;
#endif
 
#if WITH_METADATA
    COREUOBJECT_API bool HasMetaData( const TCHAR* Key, int32 NameIndex=INDEX_NONE ) const;
 
    COREUOBJECT_API FString GetMetaData( const TCHAR* Key, int32 NameIndex=INDEX_NONE, bool bAllowRemap=true ) const;
 
    COREUOBJECT_API void SetMetaData( const TCHAR* Key, const TCHAR* InValue, int32 NameIndex=INDEX_NONE) const;
    
    COREUOBJECT_API void RemoveMetaData( const TCHAR* Key, int32 NameIndex=INDEX_NONE ) const;
#endif // WITH_METADATA
    
    template <typename T>
    inline static FString GetValueAsString( const TCHAR* EnumPath, const T EnumeratorValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        return GetValueAsString_Internal(EnumPath, (int64)EnumeratorValue);
    }
 
    template <typename T>
    UE_FORCEINLINE_HINT static FString GetValueAsString( const TCHAR* EnumPath, const TEnumAsByte<T> EnumeratorValue)
    {
        return GetValueAsString_Internal(EnumPath, (int64)EnumeratorValue.GetValue());
    }
 
    template< class T >
    UE_FORCEINLINE_HINT static void GetValueAsString( const TCHAR* EnumPath, const T EnumeratorValue, FString& out_StringValue )
    {
        out_StringValue = GetValueAsString( EnumPath, EnumeratorValue );
    }
 
    template <typename T>
    inline static FString GetValueOrBitfieldAsString(const TCHAR* EnumPath, const T EnumeratorValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        return GetValueOrBitfieldAsString_Internal(EnumPath, (int64)EnumeratorValue);
    }
 
    template <typename T>
    UE_FORCEINLINE_HINT static FString GetValueOrBitfieldAsString(const TCHAR* EnumPath, const TEnumAsByte<T> EnumeratorValue)
    {
        return GetValueOrBitfieldAsString_Internal(EnumPath, (int64)EnumeratorValue.GetValue());
    }
 
    template< class T >
    UE_FORCEINLINE_HINT static void GetValueOrBitfieldAsString(const TCHAR* EnumPath, const T EnumeratorValue, FString& out_StringValue)
    {
        out_StringValue = GetValueOrBitfieldAsString( EnumPath, EnumeratorValue );
    }
    template <typename T>
    inline static FText GetDisplayValueAsText( const TCHAR* EnumPath, const T EnumeratorValue )
    {
        // For the C++ enum.
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        return GetDisplayValueAsText_Internal(EnumPath, (int64)EnumeratorValue);
    }
 
    template <typename T>
    UE_FORCEINLINE_HINT static FText GetDisplayValueAsText( const TCHAR* EnumPath, const TEnumAsByte<T> EnumeratorValue)
    {
        return GetDisplayValueAsText_Internal(EnumPath, (int64)EnumeratorValue.GetValue());
    }
 
    template< class T >
    UE_FORCEINLINE_HINT static void GetDisplayValueAsText( const TCHAR* EnumPath, const T EnumeratorValue, FText& out_TextValue )
    {
        out_TextValue = GetDisplayValueAsText( EnumPath, EnumeratorValue);
    }
 
    template<typename EnumType>
    inline static FName GetValueAsName(const EnumType EnumeratorValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<EnumType>::Value, "Should only call this with enum types");
        UEnum* EnumClass = StaticEnum<EnumType>();
        check(EnumClass != nullptr);
        return EnumClass->GetNameByValue((int64)EnumeratorValue);
    }
 
    template<typename EnumType>
    UE_FORCEINLINE_HINT static FName GetValueAsName(const TEnumAsByte<EnumType> EnumeratorValue)
    {
        return GetValueAsName(EnumeratorValue.GetValue());
    }
 
    template<typename EnumType>
    UE_FORCEINLINE_HINT static void GetValueAsName(const EnumType EnumeratorValue, FName& out_NameValue )
    {
        out_NameValue = GetValueAsName(EnumeratorValue);
    }
 
    template<typename EnumType>
    inline static FString GetValueAsString(const EnumType EnumeratorValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<EnumType>::Value, "Should only call this with enum types");
        return GetValueAsName(EnumeratorValue).ToString();
    }
 
    template<typename EnumType>
    UE_FORCEINLINE_HINT static FString GetValueAsString(const TEnumAsByte<EnumType> EnumeratorValue)
    {
        return GetValueAsString(EnumeratorValue.GetValue());
    }
 
    template<typename EnumType>
    UE_FORCEINLINE_HINT static void GetValueAsString(const EnumType EnumeratorValue, FString& out_StringValue )
    {
        out_StringValue = GetValueAsString(EnumeratorValue );
    }
 
    template<
        typename EnumType
        UE_REQUIRES(TIsEnum<EnumType>::Value)
    >
    inline static FString GetValueOrBitfieldAsString(const EnumType EnumeratorValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<EnumType>::Value, "Should only call this with enum types");
        UEnum* EnumClass = StaticEnum<EnumType>();
        check(EnumClass != nullptr);
        return EnumClass->GetValueOrBitfieldAsString((int64)EnumeratorValue);
    }
 
    // TEnumAsByte produces a warning if you use it with EnumClass, so this UE_REQUIRES keeps this overload
    // from being matched in that case
    template<
        typename EnumType
        UE_REQUIRES(!TIsEnumClass<EnumType>::Value)
    >
    UE_FORCEINLINE_HINT static FString GetValueOrBitfieldAsString(const TEnumAsByte<EnumType> EnumeratorValue)
    {
        return GetValueOrBitfieldAsString(EnumeratorValue.GetValue());
    }
 
    template<
        typename EnumType,
        typename IntegralType
        UE_REQUIRES(TIsEnum<EnumType>::Value && std::is_integral_v<IntegralType>)
    >
    inline static FString GetValueOrBitfieldAsString(const IntegralType EnumeratorValue)
    {
        // For the C++ enum.
        static_assert(TIsEnum<EnumType>::Value, "Should only call this with enum types");
        UEnum* EnumClass = StaticEnum<EnumType>();
        check(EnumClass != nullptr);
        return EnumClass->GetValueOrBitfieldAsString((int64)EnumeratorValue);
    }
 
    template<typename EnumType>
    UE_FORCEINLINE_HINT static void GetValueOrBitfieldAsString(const EnumType EnumeratorValue, FString& out_StringValue)
    {
        out_StringValue = GetValueOrBitfieldAsString(EnumeratorValue);
    }
 
    template<
        typename EnumType,
        typename IntegralType
        UE_REQUIRES(TIsEnum<EnumType>::Value && std::is_integral_v<IntegralType>)
    >
    UE_FORCEINLINE_HINT static void GetValueOrBitfieldAsString(const IntegralType EnumeratorValue, FString& out_StringValue)
    {
        out_StringValue = GetValueOrBitfieldAsString<EnumType>(EnumeratorValue);
    }
 
    template<typename EnumType>
    inline static FText GetDisplayValueAsText(const EnumType EnumeratorValue )
    {
        // For the C++ enum.
        static_assert(TIsEnum<EnumType>::Value, "Should only call this with enum types");
        UEnum* EnumClass = StaticEnum<EnumType>();
        check(EnumClass != nullptr);
        return EnumClass->GetDisplayNameTextByValue((int64)EnumeratorValue);
    }
 
    template<typename EnumType>
    UE_FORCEINLINE_HINT static FText GetDisplayValueAsText(const TEnumAsByte<EnumType> EnumeratorValue)
    {
        return GetDisplayValueAsText(EnumeratorValue.GetValue());
    }
 
    template<typename EnumType>
    UE_FORCEINLINE_HINT static void GetDisplayValueAsText(const EnumType EnumeratorValue, FText& out_TextValue )
    {
        out_TextValue = GetDisplayValueAsText(EnumeratorValue);
    }
 
    // UObject interface.
    COREUOBJECT_API virtual void Serialize(FArchive& Ar) override;
    COREUOBJECT_API virtual void BeginDestroy() override;
    // End of UObject interface.
 
    COREUOBJECT_API ~UEnum();
 
    // Helper function for UHT - calculate max enum value when UHT was not able to parse all enum values
    consteval static inline int64 CalculateMaxEnumValue(std::initializer_list<int64> Values, EEnumFlags InFlags)
    {
        check(Values.size() != 0); // UHT should only generate a call to this when there are values
        if (EnumHasAllFlags(InFlags, EEnumFlags::Flags))
        {
            int64 CombinedFlags = 0;
            for (int64 Val : Values)
            {
                if (FMath::IsPowerOfTwo(Val))
                {
                    CombinedFlags |= Val;
                }
            }
            return 1 + CombinedFlags;
        }
        return 1 + *Algo::MaxElement(Values);
    }
 
protected:
    class FNameData
    {
        // Tag bit to show wehther a pointer is dynamically allocated, or points to a static allocation
        static inline constexpr UPTRINT TagDynamic = 0x1;
        // Mask to retrieve a readable pointer from the tagged pointer regardless of whether it is static or dynamic
        static inline constexpr UPTRINT MaskPointer = ~0x1;
        union
        {
#if UE_WITH_CONSTINIT_UOBJECT
            // Immutable array of string constants from UHT. This union member is active until full compiled-in UObject construction in ProcessNewlyLoadedUObjects
            const UTF8CHAR* const* StaticNamesUTF8;
#endif // UE_WITH_CONSTINIT_UOBJECT
            // Tagged FName* pointer, noting whether array is dynamically allocated 
            UPTRINT TaggedNames = 0;
        };
        union
        {
#if UE_WITH_CONSTINIT_UOBJECT
            // Immutable array of values from UHT. This union member may be active for the entire process lifetime.
            const int64* StaticValues;
#endif // UE_WITH_CONSTINIT_UOBJECT
            // Tagged int64* pointer noting whether array is dynamically allocated
            UPTRINT TaggedValues = 0;
        };
        // Both arrays contain same number of values
        int32 NumValues = 0;
 
        void DeleteNames();
        void DeleteValues();
 
        FName* AllocateNames(int32 InNum);
        int64* AllocateValues(int32 InNum);
 
    public:
        UE_NONCOPYABLE(FNameData)
        constexpr FNameData() = default;
#if UE_WITH_CONSTINIT_UOBJECT
        consteval FNameData(int32 InNum, const UTF8CHAR* const* InStaticNamesUTF8, const int64* InValues)
        : StaticNamesUTF8(InStaticNamesUTF8)
        , StaticValues(InValues)
        , NumValues(InNum)
        {
        }
#endif // UE_WITH_CONSTINIT_UOBJECT
        ~FNameData();
 
        [[nodiscard]] inline int32 Num() const 
        { 
            return NumValues; 
        }
 
        [[nodiscard]] inline bool IsValidIndex(int32 Index) const
        {
            return Index >= 0 && Index < NumValues;
        }
 
        [[nodiscard]] inline TPair<FName, int64> operator[](int32 Index) const
        {
            check(IsValidIndex(Index));
            return { GetNames()[Index], GetValues()[Index] };
        } 
 
#if UE_WITH_CONSTINIT_UOBJECT
        // Initialize from constinit data
        void InitializeFromCompiledInData();
#endif //UE_WITH_CONSTINIT_UOBJECT
        // Initialize from legacy serialization of names without values
        void Initialize(const TArray<FName>& InNames);
        // Initialize from legacy serialization of names with byte values
        void Initialize(const TArray<TPair<FName, uint8>>& InNames);
        // Initialize from names and int64 values
        void Initialize(const TArray<TPair<FName, int64>>& InNames);
        // Initialize from names and int64 values with a placeholder to generate a max element
        COREUOBJECT_API void InitializeWithPlaceholder(const TArray<TPair<FName, int64>>& InNames, int64 MaxValue);
        // If necessary, replace values with sequential values counting up from zero
        COREUOBJECT_API void MakeValuesSequentialFromZero();
        // Deallocate arrays - ConstInit objects should not delete the values as they are a static array created by UHT.
        COREUOBJECT_API void Empty();
 
        COREUOBJECT_API void UsePlaceholder(FName InName, int64 InValue);
        COREUOBJECT_API void DiscardPlaceholder();
 
        // Get a mutable view over the names
        [[nodiscard]] inline TArrayView<FName> GetMutableNames()
        {
            checkfSlow(!!(TaggedNames & TagDynamic), TEXT("This function should only be used after compiled-in enums have copied their static string names into FNames"));
            return MakeArrayView(reinterpret_cast<FName*>(TaggedNames & MaskPointer), NumValues);
        }
 
        // Get an immutable view over the names 
        [[nodiscard]] inline TConstArrayView<FName> GetNames() const
        {
            checkfSlow(!!(TaggedNames & TagDynamic), TEXT("This function should only be used after compiled-in enums have copied their static string names into FNames"));
            return MakeConstArrayView(reinterpret_cast<const FName*>(TaggedNames & MaskPointer), NumValues);
        }
 
        // Get an immutable view over the values
        [[nodiscard]] inline TConstArrayView<int64> GetValues() const
        {
            return MakeConstArrayView(reinterpret_cast<int64*>(TaggedValues & MaskPointer), NumValues);
        }
 
        // Read-only ranged-for support.
        struct FIteratorEnd
        {
        };
        struct FIterator
        {
            void operator++()
            {
                ++Index;
            }
 
            bool operator==(FIteratorEnd) const
            {
                return Index >= Num;
            }
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
            bool operator!=(FIteratorEnd) const
            {
                return Index < Num;
            }
#endif
 
            TPair<FName, int64> operator*() const
            {
                return { Names[Index], Values[Index] };
            }
 
            int32 Index = 0;
            int32 Num;
            const FName* Names;
            const int64* Values;
        };
 
        inline FIterator begin() const 
        { 
            return FIterator{ 
                .Num = Num(),
                .Names = reinterpret_cast<FName*>(TaggedNames & MaskPointer),
                .Values = reinterpret_cast<int64*>(TaggedValues & MaskPointer) 
            };
        }
        inline FIteratorEnd end() const 
        {
            return FIteratorEnd(); 
        }
    } Names;
 
    ECppForm CppForm;
 
    EEnumFlags EnumFlags;
 
    FName EnumPackage;
    
    FEnumDisplayNameFn EnumDisplayNameFn;
 
    static FRWLock AllEnumNamesLock;
 
    static TMap<FName, TMap<FName, UEnum*> > AllEnumNames;
 
    UE_DEPRECATED(5.1, "AddNamesToMasterList is deprecated, please use AddNamesToPrimaryList instead.")
    void AddNamesToMasterList()
    {
        AddNamesToPrimaryList();
    }
 
    COREUOBJECT_API void AddNamesToPrimaryList();
 
    COREUOBJECT_API static int64 GetMaxEnumValue(const TArray<TPair<FName, int64>>& InNames, EEnumFlags InFlags);
 
private:
 
    static UEnum* LookupAllEnumNamesWithOptions(FName PackageName, EFindFirstObjectOptions Options, TFunctionRef<bool(FName)> CompareNameFunction);
 
    inline static FString GetValueAsString_Internal( const TCHAR* EnumPath, const int64 EnumeratorValue)
    {
        UEnum* EnumClass = FindObject<UEnum>( nullptr, EnumPath );
        UE_CLOG( !EnumClass, LogClass, Fatal, TEXT("Couldn't find enum '%s'"), EnumPath );
        return EnumClass->GetNameStringByValue(EnumeratorValue);
    }
 
    inline static FString GetValueOrBitfieldAsString_Internal(const TCHAR* EnumPath, const int64 EnumeratorValue)
    {
        UEnum* EnumClass = FindObject<UEnum>(nullptr, EnumPath);
        UE_CLOG(!EnumClass, LogClass, Fatal, TEXT("Couldn't find enum '%s'"), EnumPath);
        return EnumClass->GetValueOrBitfieldAsString(EnumeratorValue);
    }
 
    inline static FText GetDisplayValueAsText_Internal( const TCHAR* EnumPath, const int64 EnumeratorValue )
    {
        UEnum* EnumClass = FindObject<UEnum>(nullptr, EnumPath);
        UE_CLOG(!EnumClass, LogClass, Fatal, TEXT("Couldn't find enum '%s'"), EnumPath);
        return EnumClass->GetDisplayNameTextByValue(EnumeratorValue);
    }
 
    void RenameNamesAfterDuplication();
 
    FString GetBaseEnumNameOnDuplication() const;
};
 
/*-----------------------------------------------------------------------------
    UClass.
-----------------------------------------------------------------------------*/
 
struct FCppClassTypeTraitsBase
{
    enum
    {
        IsAbstract = false
    };
};
 
 
template<class CPPCLASS>
struct TCppClassTypeTraits : public FCppClassTypeTraitsBase
{
    enum
    {
        IsAbstract = TIsAbstract<CPPCLASS>::Value
    };
};
 
 
struct ICppClassTypeInfo
{
    virtual bool IsAbstract() const = 0;
};
 
 
struct FCppClassTypeInfoStatic
{
    bool bIsAbstract;
};
 
 
struct FCppClassTypeInfo : ICppClassTypeInfo
{
    constexpr explicit FCppClassTypeInfo(const FCppClassTypeInfoStatic* InInfo)
        : Info(InInfo)
    {
    }
 
    // Non-copyable
    FCppClassTypeInfo(const FCppClassTypeInfo&) = delete;
    FCppClassTypeInfo& operator=(const FCppClassTypeInfo&) = delete;
 
    // ICppClassTypeInfo implementation
    virtual bool IsAbstract() const override
    {
        return Info->bIsAbstract;
    }
 
private:
    const FCppClassTypeInfoStatic* Info;
};
 
 
struct FImplementedInterface
{
    TObjectPtr<UClass> Class;
    int32 PointerOffset;
    bool bImplementedByK2;
 
    FImplementedInterface()
        : Class(nullptr)
        , PointerOffset(0)
        , bImplementedByK2(false)
    {}
    explicit FImplementedInterface(UClass* InClass, int32 InOffset, bool InImplementedByK2)
        : Class(InClass)
        , PointerOffset(InOffset)
        , bImplementedByK2(InImplementedByK2)
    {}
 
#if UE_WITH_CONSTINIT_UOBJECT
    explicit FImplementedInterface(UE::CodeGen::ConstInit::FClassImplementedInterface InCompiledIn);
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    friend COREUOBJECT_API FArchive& operator<<(FArchive& Ar, FImplementedInterface& A);
};
 
 
struct FNativeFunctionLookup
{
    FName Name;
    FNativeFuncPtr Pointer;
 
#if UE_WITH_CONSTINIT_UOBJECT
    explicit FNativeFunctionLookup(UE::CodeGen::FClassNativeFunction InCompiledIn)
        :   Name(InCompiledIn.NameUTF8)
        ,   Pointer(InCompiledIn.Pointer)
    {}
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    FNativeFunctionLookup(FName InName, FNativeFuncPtr InPointer)
        :   Name(InName)
        ,   Pointer(InPointer)
    {}
};
 
 
namespace EIncludeSuperFlag
{
    enum Type
    {
        ExcludeSuper,
        IncludeSuper
    };
}
 
struct FClassFunctionLinkInfo
{
    UFunction* (*CreateFuncPtr)();
    const char* FuncNameUTF8;
};
 
 
enum class EGetSparseClassDataMethod : uint8
{
    CreateIfNull,
    ArchetypeIfNull,
    ReturnIfNull,
    DeferIfNull,
};
 
template<class T>
void InternalConstructor( const FObjectInitializer& X );
 
template<class T>
UObject* InternalVTableHelperCtorCaller(FVTableHelper& Helper);
 
UCLASS(MinimalAPI, Within=Package, Config = Engine)
class UClass : public UStruct
{
    GENERATED_BODY()
 
public:
    friend class FRestoreClassInfo;
    friend class FBlueprintEditorUtils;
    friend class FBlueprintCompileReinstancer;
    friend struct FBlueprintCompilationManagerImpl;
 
    typedef void        (*ClassConstructorType)             (const FObjectInitializer&);
    typedef UObject*    (*ClassVTableHelperCtorCallerType)  (FVTableHelper& Helper);
    typedef UClass* (*StaticClassFunctionType)();
 
    ClassConstructorType ClassConstructor;
    ClassVTableHelperCtorCallerType ClassVTableHelperCtorCaller;
    FUObjectCppClassStaticFunctions CppClassStaticFunctions;
 
    mutable int32 ClassUnique;
 
    int32 FirstOwnedClassRep = 0;
 
    bool bCooked;
 
    bool bLayoutChanging;
 
    EClassFlags ClassFlags;
 
    EClassCastFlags ClassCastFlags;
 
    UPROPERTY(SkipSerialization)
    TObjectPtr<UClass> ClassWithin;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(SkipSerialization)
    TObjectPtr<UObject> ClassGeneratedBy;
 
    FField* PropertiesPendingDestruction;
 
    COREUOBJECT_API void DestroyPropertiesPendingDestruction();
#endif
 
#if WITH_EDITOR
    virtual void ConditionalRecompileClass(FUObjectSerializeContext* InLoadContext) {}
    virtual void FlushCompilationQueueForLevel() {}
#endif //WITH_EDITOR
 
    union
    {
        FName ClassConfigName = {};
#if UE_WITH_CONSTINIT_UOBJECT
        // CONSTINIT_UOBJECT_TODO: Size increase
        const TCHAR* CompiledInClassConfigName;
#endif // UE_WITH_CONSTINIT_UOBJECT
    };
 
    TArray<FRepRecord> ClassReps;
 
    UPROPERTY(SkipSerialization)
    TArray<TObjectPtr<UField>> NetFields;
 
#if WITH_EDITOR
    // Editor only properties
    COREUOBJECT_API void GetHideFunctions(TArray<FString>& OutHideFunctions) const;
    COREUOBJECT_API bool IsFunctionHidden(const TCHAR* InFunction) const;
    COREUOBJECT_API void GetAutoExpandCategories(TArray<FString>& OutAutoExpandCategories) const;
    COREUOBJECT_API bool IsAutoExpandCategory(const TCHAR* InCategory) const;
    COREUOBJECT_API void GetPrioritizeCategories(TArray<FString>& OutPrioritizedCategories) const;
    COREUOBJECT_API bool IsPrioritizeCategory(const TCHAR* InCategory) const;
    COREUOBJECT_API void GetAutoCollapseCategories(TArray<FString>& OutAutoCollapseCategories) const;
    COREUOBJECT_API bool IsAutoCollapseCategory(const TCHAR* InCategory) const;
    COREUOBJECT_API void GetClassGroupNames(TArray<FString>& OutClassGroupNames) const;
    COREUOBJECT_API bool IsClassGroupName(const TCHAR* InGroupName) const;
#endif
    inline void CallAddReferencedObjects(UObject* This, FReferenceCollector& Collector) const
    {
        // The object must of this class type.
        check(This->IsA(this)); 
        // This should always be set to something, at the very least to UObject::ARO
        check(CppClassStaticFunctions.GetAddReferencedObjects() != nullptr);
        CppClassStaticFunctions.GetAddReferencedObjects()(This, Collector);
    }
 
#if WITH_EDITORONLY_DATA
    void CallDeclareCustomVersions(FArchive& Ar) const
    {
        check(CppClassStaticFunctions.GetDeclareCustomVersions());
        CppClassStaticFunctions.GetDeclareCustomVersions()(Ar, this);
    }
 
    void CallAppendToClassSchema(FAppendToClassSchemaContext& Context) const
    {
        check(CppClassStaticFunctions.GetAppendToClassSchema());
        CppClassStaticFunctions.GetAppendToClassSchema()(Context);
    }
 
    void CallDeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses) const
    {
        check(CppClassStaticFunctions.GetDeclareConstructClasses());
        CppClassStaticFunctions.GetDeclareConstructClasses()(OutConstructClasses, this);
    }
#endif
 
    UE_DEPRECATED(5.6, "ClassDefaultObject will be made private in the next release. For general purpose access to the CDO consider using the global GetDefault<>() or GetMutableDefault<>() functions.")
    UPROPERTY(SkipSerialization)
    TObjectPtr<UObject> ClassDefaultObject;
 
protected:
#if UE_WITH_REMOTE_OBJECT_HANDLE
    TObjectPtr<UObject> ImmutableDefaultObject;
#endif
 
    void* SparseClassData;
 
    TObjectPtr<UScriptStruct> SparseClassDataStruct;
 
    bool bNeedsDynamicSubobjectInstancing = false;
 
public:
    COREUOBJECT_API const void* GetSparseClassData(const EGetSparseClassDataMethod GetMethod);
 
    void* GetOrCreateSparseClassData() { return const_cast<void*>(GetSparseClassData(EGetSparseClassDataMethod::CreateIfNull)); }
 
    COREUOBJECT_API UScriptStruct* GetSparseClassDataStruct() const;
 
    COREUOBJECT_API void SetSparseClassDataStruct(UScriptStruct* InSparseClassDataStruct);
 
    COREUOBJECT_API void ClearSparseClassDataStruct(bool bInRecomplingOnLoad);
 
    static COREUOBJECT_API void AssembleReferenceTokenStreams();
 
#if WITH_EDITOR
    void GenerateFunctionList(TArray<FName>& OutArray) const 
    { 
        FUClassFuncScopeReadLock ScopeLock(FuncMapLock);
        FuncMap.GenerateKeyArray(OutArray); 
    }
#endif // WITH_EDITOR
 
protected:
    COREUOBJECT_API void* CreateSparseClassData();
 
    COREUOBJECT_API void CleanupSparseClassData();
 
private:
#if WITH_EDITOR
    TOptional<FCppClassTypeInfo> CppTypeInfo;
#endif
 
    TMap<FName, TObjectPtr<UFunction>> FuncMap;
 
    mutable FUClassFuncLock FuncMapLock;
 
    mutable TMap<FName, UFunction*> AllFunctionsCache;
 
    mutable FUClassFuncLock AllFunctionsCacheLock;
 
public:
    union
    { 
        TArray<FImplementedInterface> Interfaces = {};
 
#if UE_WITH_CONSTINIT_UOBJECT
        TConstArrayView<UE::CodeGen::ConstInit::FClassImplementedInterface> CompiledInInterfaces;
#endif // UE_WITH_CONSTINIT_UOBJECT
    };
 
    UE::GC::FSchemaOwner ReferenceSchema;
 
    union
    { 
        TArray<FNativeFunctionLookup> NativeFunctionLookupTable = {};
 
#if UE_WITH_CONSTINIT_UOBJECT
        TConstArrayView<UE::CodeGen::FClassNativeFunction> CompiledInNativeFunctions;
#endif // UE_WITH_CONSTINIT_UOBJECT
    };
 
public:
    // Constructors
    COREUOBJECT_API UClass(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
    COREUOBJECT_API explicit UClass(const FObjectInitializer& ObjectInitializer, UClass* InSuperClass);
    COREUOBJECT_API UClass( EStaticConstructor, FName InName, uint32 InSize, uint32 InAlignment, EClassFlags InClassFlags, EClassCastFlags InClassCastFlags,
        const TCHAR* InClassConfigName, EObjectFlags InFlags, ClassConstructorType InClassConstructor,
        ClassVTableHelperCtorCallerType InClassVTableHelperCtorCaller,
        FUObjectCppClassStaticFunctions&& InCppClassStaticFunctions);
#if UE_WITH_CONSTINIT_UOBJECT
    consteval UClass(
        UE::CodeGen::ConstInit::FObjectParams ObjectParams,
        UE::CodeGen::ConstInit::FUFieldParams FieldParams,
        UE::CodeGen::ConstInit::FStructParams StructParams,
        UE::CodeGen::ConstInit::FClassParams Params
    );
#endif
 
    // Destructor
    COREUOBJECT_API ~UClass();
 
#if WITH_RELOAD
    COREUOBJECT_API bool HotReloadPrivateStaticClass(
        uint32          InSize,
        EClassFlags     InClassFlags,
        EClassCastFlags InClassCastFlags,
        const TCHAR*    InConfigName,
        ClassConstructorType InClassConstructor,
        ClassVTableHelperCtorCallerType InClassVTableHelperCtorCaller,
        FUObjectCppClassStaticFunctions&& InCppClassStaticFunctions,
        class UClass* TClass_Super_StaticClass,
        class UClass* TClass_WithinClass_StaticClass
        );
 
 
    COREUOBJECT_API bool ReplaceNativeFunction(FName InName, FNativeFuncPtr InPointer, bool bAddToFunctionRemapTable);
#endif
 
    COREUOBJECT_API virtual UClass* GetAuthoritativeClass();
    const UClass* GetAuthoritativeClass() const { return const_cast<UClass*>(this)->GetAuthoritativeClass(); }
 
    COREUOBJECT_API void AddNativeFunction(const ANSICHAR* InName, FNativeFuncPtr InPointer);
 
    COREUOBJECT_API void AddNativeFunction(const WIDECHAR* InName, FNativeFuncPtr InPointer);
 
    void AddFunctionToFunctionMap(UFunction* Function, FName FuncName)
    {
        {
            FUClassFuncScopeWriteLock ScopeLock(FuncMapLock);
            FuncMap.Add(FuncName, Function);
        }
        {
            // Remove from the function cache if it exists
            FUClassFuncScopeWriteLock ScopeLock(AllFunctionsCacheLock);
            AllFunctionsCache.Remove(FuncName);
        }
    }
 
#if UE_WITH_CONSTINIT_UOBJECT
    void InitFuncMap();
#else 
    COREUOBJECT_API void CreateLinkAndAddChildFunctionsToMap(const FClassFunctionLinkInfo* Functions, uint32 NumFunctions);
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    void RemoveFunctionFromFunctionMap(UFunction* Function)
    {
        {
            FUClassFuncScopeWriteLock ScopeLock(FuncMapLock);
            FuncMap.Remove(Function->GetFName());
        }
        {
            // Remove from the function cache if it exists
            FUClassFuncScopeWriteLock ScopeLock(AllFunctionsCacheLock);
            AllFunctionsCache.Remove(Function->GetFName());
        }
    }
 
    COREUOBJECT_API void ClearFunctionMapsCaches();
 
    COREUOBJECT_API UFunction* FindFunctionByName(FName InName, EIncludeSuperFlag::Type IncludeSuper = EIncludeSuperFlag::IncludeSuper) const;
 
    // UObject interface.
    COREUOBJECT_API virtual void Serialize(FArchive& Ar) override;
    COREUOBJECT_API virtual void PostLoad() override;
    COREUOBJECT_API virtual void FinishDestroy() override;
    COREUOBJECT_API virtual void DeferredRegister(UClass* UClassStaticClass, const TCHAR* PackageName, const TCHAR* InName
#if UE_WITH_REMOTE_OBJECT_HANDLE
        , FRemoteObjectId RemoteId
#endif // UE_WITH_REMOTE_OBJECT_HANDLE
    ) override;
    COREUOBJECT_API virtual bool Rename(const TCHAR* NewName = nullptr, UObject* NewOuter = nullptr, ERenameFlags Flags = REN_None) override;
    COREUOBJECT_API virtual void TagSubobjects(EObjectFlags NewFlags) override;
    COREUOBJECT_API virtual void PostInitProperties() override;
    static COREUOBJECT_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    COREUOBJECT_API virtual FRestoreForUObjectOverwrite* GetRestoreForUObjectOverwrite() override;
    COREUOBJECT_API virtual FString GetDesc() override;
    COREUOBJECT_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    COREUOBJECT_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
 
#if WITH_EDITOR
protected:
    COREUOBJECT_API virtual void ThreadedPostLoadAssetRegistryTagsOverride(FPostLoadAssetRegistryTagsContext& Context) const;
public:
#endif // WITH_EDITOR
 
    virtual bool IsAsset() const override { return false; } 
    virtual bool IsNameStableForNetworking() const override { return true; } // For now, assume all classes have stable net names
    COREUOBJECT_API virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps) override;
    // End of UObject interface.
 
    // UField interface.
    COREUOBJECT_API virtual void Bind() override;
    COREUOBJECT_API virtual const TCHAR* GetPrefixCPP() const override;
    // End of UField interface.
 
    // UStruct interface.
    COREUOBJECT_API virtual void Link(FArchive& Ar, bool bRelinkExistingProperties) override;
    COREUOBJECT_API virtual void SetSuperStruct(UStruct* NewSuperStruct) override;
    COREUOBJECT_API virtual bool IsStructTrashed() const override;
    UE_INTERNAL COREUOBJECT_API virtual EStructPropertyLinkFlags GetPropertyLinkFlags(UStruct* ContainerStruct, FProperty* Property) const;
    // End of UStruct interface.
 
#if WITH_EDITORONLY_DATA
    UE_INTERNAL COREUOBJECT_API virtual bool ActivateTrackingPropertyValueFlag(EPropertyValueFlags Flags, void* Data) const override;
    UE_INTERNAL COREUOBJECT_API virtual bool IsTrackingPropertyValueFlag(EPropertyValueFlags Flags, const void* Data) const override;
    UE_INTERNAL COREUOBJECT_API virtual bool HasPropertyValueFlag(EPropertyValueFlags Flags, const void* Data, const FProperty* Property, int32 ArrayIndex = 0) const override;
    UE_INTERNAL COREUOBJECT_API virtual void SetPropertyValueFlag(EPropertyValueFlags Flags, bool bValue, void* Data, const FProperty* Property, int32 ArrayIndex = 0) const override;
    UE_INTERNAL COREUOBJECT_API virtual void ResetPropertyValueFlags(EPropertyValueFlags Flags, void* Data) const override;
    UE_INTERNAL COREUOBJECT_API virtual void SerializePropertyValueFlags(EPropertyValueFlags Flags, void* Data, FStructuredArchiveRecord Record, FArchiveFieldName Name) const override;
#endif // WITH_EDITORONLY_DATA
 
    UE_FORCEINLINE_HINT FTopLevelAssetPath GetClassPathName() const
    {
        return GetStructPathName();
    }
 
    static COREUOBJECT_API UField* TryFindTypeSlow(UClass* TypeClass, FStringView InPathNameOrShortName, EFindFirstObjectOptions InOptions = EFindFirstObjectOptions::None);
 
    template <typename T>
    static T* TryFindTypeSlow(FStringView InShortNameOrPathName, EFindFirstObjectOptions InOptions = EFindFirstObjectOptions::None)
    {
        return (T*)TryFindTypeSlow(T::StaticClass(), InShortNameOrPathName, InOptions);
    }
 
    static COREUOBJECT_API UField* TryFindTypeSlowSafe(UClass* TypeClass, FStringView InPathNameOrShortName, EFindFirstObjectOptions InOptions = EFindFirstObjectOptions::None);
 
    template <typename T>
    static T* TryFindTypeSlowSafe(FStringView InShortNameOrPathName, EFindFirstObjectOptions InOptions = EFindFirstObjectOptions::None)
    {
        return (T*)TryFindTypeSlowSafe(T::StaticClass(), InShortNameOrPathName, InOptions);
    }
 
    static COREUOBJECT_API FTopLevelAssetPath TryConvertShortTypeNameToPathName(UClass* TypeClass, FStringView InShortTypeName, ELogVerbosity::Type AmbiguousMessageVerbosity = ELogVerbosity::NoLogging, const TCHAR* AmbiguousClassMessage = nullptr);
 
    template <typename T>
    static FTopLevelAssetPath TryConvertShortTypeNameToPathName(FStringView InShortTypeName, ELogVerbosity::Type AmbiguousMessageVerbosity = ELogVerbosity::NoLogging, const TCHAR* AmbiguousClassMessage = nullptr)
    {
        return TryConvertShortTypeNameToPathName(T::StaticClass(), InShortTypeName, AmbiguousMessageVerbosity, AmbiguousClassMessage);
    }
 
    static COREUOBJECT_API bool TryFixShortClassNameExportPath(FString& InOutExportPathToFix,
        ELogVerbosity::Type AmbiguousMessageVerbosity = ELogVerbosity::NoLogging,
        const TCHAR* AmbiguousClassMessage = nullptr, bool bClearOnError = false);
 
    static COREUOBJECT_API FString ConvertPathNameToShortTypeName(FStringView InClassPathOrShortTypeName);
 
    static COREUOBJECT_API FString ConvertFullNameToShortTypeFullName(FStringView InFullName);
 
    static COREUOBJECT_API bool IsShortTypeName(FStringView ClassPathOrShortTypeName);
 
#if WITH_EDITOR
    const ICppClassTypeInfo* GetCppTypeInfo() const
    {
        return CppTypeInfo ? &CppTypeInfo.GetValue() : nullptr;
    }
#endif
 
    void SetCppTypeInfoStatic(const FCppClassTypeInfoStatic* InCppTypeInfoStatic)
    {
#if WITH_EDITOR
        check(InCppTypeInfoStatic);
        CppTypeInfo.Emplace(InCppTypeInfoStatic);
#endif
    }
    
    COREUOBJECT_API const FString GetConfigName() const;
 
    UClass* GetSuperClass() const
    {
        return (UClass*)GetSuperStruct();
    }
 
    static COREUOBJECT_API class FFeedbackContext& GetDefaultPropertiesFeedbackContext();
 
    int32 GetDefaultsCount()
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return ClassDefaultObject != nullptr ? GetPropertiesSize() : 0;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UObject* GetDefaultObject(bool bCreateIfNeeded = true) const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        if (ClassDefaultObject == nullptr && bCreateIfNeeded)
        {
            InternalCreateDefaultObjectWrapper();
        }
 
        return ClassDefaultObject;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    const UObject* GetImmutableDefaultObject(bool bCreateIfNeeded = true) const
    {
        if (ImmutableDefaultObject == nullptr && bCreateIfNeeded)
        {
            InternalCreateImmutableDefaultObject();
        }
        return ImmutableDefaultObject;
    }
#endif
 
    COREUOBJECT_API void SetDefaultObject(UObject* InClassDefaultObject);
 
    inline bool CheckDefaultObjectIsValidLowLevelFast(const int32 AlignmentCheck) const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return ClassDefaultObject != nullptr && ((UPTRINT)ObjectPtr_Private::Friend::NoAccessTrackingGet(ClassDefaultObject) & AlignmentCheck) == 0;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    virtual void PostInitInstance(UObject* InObj, FObjectInstancingGraph* InstanceGraph) {}
 
    virtual void PostLoadInstance(UObject* InObj) {}
 
    virtual void InitPropertiesFromCustomList(uint8* DataPtr, const uint8* DefaultDataPtr) {}
 
    virtual void SetupObjectInitializer(FObjectInitializer& ObjectInitializer) const {}
 
    virtual bool CanCreateAssetOfClass() const
    {
        return true;
    }
 
    COREUOBJECT_API FName GetDefaultObjectName() const;
 
    virtual uint8* GetPersistentUberGraphFrame(UObject* Obj, UFunction* FuncToCheck) const
    {
        return nullptr;
    }
 
    virtual void CreatePersistentUberGraphFrame(UObject* Obj, bool bCreateOnlyIfEmpty = false, bool bSkipSuperClass = false, UClass* OldClass = nullptr) const
    {
    }
    
    virtual void DestroyPersistentUberGraphFrame(UObject* Obj, bool bSkipSuperClass = false) const
    {
    }
 
    template<class T>
    T* GetDefaultObject() const
    {
        UObject *Ret = GetDefaultObject();
        check(Ret->IsA(T::StaticClass()));
        return (T*)Ret;
    }
 
    COREUOBJECT_API UObject* GetDefaultSubobjectByName(FName ToFind);
 
    void AddDefaultSubobject(UObject* NewSubobject, const UClass* BaseClass)
    {
        // this component must be a derived class of the base class
        check(NewSubobject->IsA(BaseClass));
        // the outer of the component must be of my class or some superclass of me
        check(IsChildOf(NewSubobject->GetOuter()->GetClass()));
    }
 
    COREUOBJECT_API void GetDefaultObjectSubobjects(TArray<UObject*>& OutDefaultSubobjects);
 
    UE_FORCEINLINE_HINT bool HasAnyClassFlags( EClassFlags FlagsToCheck ) const
    {
        return EnumHasAnyFlags(ClassFlags, FlagsToCheck) != 0;
    }
 
    UE_FORCEINLINE_HINT bool HasAllClassFlags( EClassFlags FlagsToCheck ) const
    {
        return EnumHasAllFlags(ClassFlags, FlagsToCheck);
    }
 
    UE_FORCEINLINE_HINT EClassFlags GetClassFlags() const
    {
        return ClassFlags;
    }
 
    UE_FORCEINLINE_HINT bool HasAnyCastFlag(EClassCastFlags FlagToCheck) const
    {
        return (ClassCastFlags&FlagToCheck) != 0;
    }
    UE_FORCEINLINE_HINT bool HasAllCastFlags(EClassCastFlags FlagsToCheck) const
    {
        return (ClassCastFlags&FlagsToCheck) == FlagsToCheck;
    }
 
    COREUOBJECT_API FString GetDescription() const;
 
    COREUOBJECT_API void AssembleReferenceTokenStream(bool bForce = false);
 
    COREUOBJECT_API bool ImplementsInterface(const class UClass* SomeInterface) const;
 
    COREUOBJECT_API virtual void SerializeDefaultObject(UObject* Object, FStructuredArchive::FSlot Slot);
 
    virtual void SerializeDefaultObject(UObject* Object, FArchive& Ar) final
    {
        SerializeDefaultObject(Object, FStructuredArchiveFromArchive(Ar).GetSlot());
    }
 
    COREUOBJECT_API void SerializeSparseClassData(FStructuredArchive::FSlot Slot);
 
    COREUOBJECT_API virtual void PostLoadDefaultObject(UObject* Object);
 
    COREUOBJECT_API virtual void PurgeClass(bool bRecompilingOnLoad);
 
    static COREUOBJECT_API UClass* FindCommonBase(UClass* InClassA, UClass* InClassB);
 
    static COREUOBJECT_API UClass* FindCommonBase(const TArray<UClass*>& InClasses);
 
    COREUOBJECT_API virtual bool IsFunctionImplementedInScript(FName InFunctionName) const;
 
    COREUOBJECT_API virtual bool HasProperty(const FProperty* InProperty) const;
 
    virtual UObject* FindArchetype(const UClass* ArchetypeClass, const FName ArchetypeName) const { return nullptr; }
 
    COREUOBJECT_API virtual UObject* GetArchetypeForCDO() const;
 
    COREUOBJECT_API const void* GetArchetypeForSparseClassData(
        const EGetSparseClassDataMethod GetMethod = EGetSparseClassDataMethod::ArchetypeIfNull) const;
 
    COREUOBJECT_API UScriptStruct* GetSparseClassDataArchetypeStruct() const;
 
    UE_DEPRECATED(5.5, "Replace with UE::Reflection::DoesSparseClassDataOverrideArchetype(Class, [](const FProperty*){return true;})")
    COREUOBJECT_API bool OverridesSparseClassDataArchetype() const;
 
    virtual void GetDefaultObjectPreloadDependencies(TArray<UObject*>& OutDeps) {}
 
    COREUOBJECT_API void SetUpRuntimeReplicationData();
 
    static COREUOBJECT_API bool IsSafeToSerializeToStructuredArchives(UClass* InClass);
 
#if WITH_EDITORONLY_DATA
    UE_INTERNAL COREUOBJECT_API virtual bool CanCreateInstanceDataObject() const;
#endif
 
#if WITH_EDITOR
    COREUOBJECT_API FTopLevelAssetPath GetReinstancedClassPathName() const;
#endif
 
    inline bool ShouldUseDynamicSubobjectInstancing() const
    {
        return bNeedsDynamicSubobjectInstancing;
    }
 
private:
    bool IsA(const UClass* Parent) const
    {
        return UObject::IsA(Parent);
    }
 
    template <typename T>
    bool Implements() const
    {
        return UObject::Implements<T>();
    }
 
    UFunction* FindFunction(FName InName) const
    {
        return UObject::FindFunction(InName);
    }
 
    UFunction* FindFunctionChecked(FName InName) const
    {
        return UObject::FindFunctionChecked(InName);
    }
 
    COREUOBJECT_API void AssembleReferenceTokenStreamInternal(bool bForce = false);
    COREUOBJECT_API void InternalCreateDefaultObjectWrapper() const;
#if UE_WITH_REMOTE_OBJECT_HANDLE
    COREUOBJECT_API void InternalCreateImmutableDefaultObject() const;
#endif
protected:
    COREUOBJECT_API virtual UObject* CreateDefaultObject();
 
#if WITH_EDITOR
    virtual FTopLevelAssetPath GetReinstancedClassPathName_Impl() const { return nullptr; }
#endif
};
 
#if UE_WITH_CONSTINIT_UOBJECT
extern COREUOBJECT_API TNoDestroy<UClass> Z_ConstInit_UClass_UClass;
extern COREUOBJECT_API TNoDestroy<UClass> Z_ConstInit_UClass_UObject;
consteval UClass::UClass(
    UE::CodeGen::ConstInit::FObjectParams ObjectParams,
    UE::CodeGen::ConstInit::FUFieldParams FieldParams,
    UE::CodeGen::ConstInit::FStructParams StructParams,
    UE::CodeGen::ConstInit::FClassParams Params
)
    // Initialization of class for UClass passes null because of constexpr evaluation order and TNoDestroy wrapper
    : Super(ObjectParams.SetClassIfUnset(&Z_ConstInit_UClass_UClass), FieldParams, StructParams)
    , ClassConstructor(Params.ClassConstructor)
    , ClassVTableHelperCtorCaller(Params.ClassVTableHelperCtorCaller)
    , CppClassStaticFunctions(Params.CppClassStaticFunctions)
    , ClassUnique(0)
    , bCooked(false)
    , bLayoutChanging(false)
    , ClassFlags(Params.ClassFlags | CLASS_Native)
    , ClassCastFlags(Params.ClassCastFlags)
    , ClassWithin(ConstEval, Params.ClassWithin ? Params.ClassWithin : &Z_ConstInit_UClass_UObject)
#if WITH_EDITORONLY_DATA
    , PropertiesPendingDestruction(nullptr)
#endif
    , CompiledInClassConfigName(Params.ConfigName)
    , ClassReps(ConstEval)
    , NetFields(ConstEval)
    , SparseClassData(nullptr)
    , SparseClassDataStruct(Params.SparseClassDataStruct)
#if WITH_EDITOR
    , CppTypeInfo(InClassParams.Place, InCppClassTypeInfo)
#endif
    , FuncMap(ConstEval)
    , FuncMapLock()
    , AllFunctionsCache(ConstEval)
    , AllFunctionsCacheLock()
    , CompiledInInterfaces(Params.Interfaces)
    , CompiledInNativeFunctions(Params.NativeFunctions)
{
    if (StructParams.Super == nullptr)
    {
        checkf(Params.NativeFunctions.Num() == 0, TEXT("UObject must have no native functions because ScriptCore will try and override it"));
    }
}
 
inline FImplementedInterface::FImplementedInterface(UE::CodeGen::ConstInit::FClassImplementedInterface InCompiledIn)
    : Class(InCompiledIn.Class)
    , PointerOffset(InCompiledIn.PointerOffset)
    , bImplementedByK2(InCompiledIn.bImplementedByK2)
{
}
#endif // UE_WITH_CONSTINIT_UOBJECT
 
template<class T>
void InternalConstructor( const FObjectInitializer& X )
{ 
    T::__DefaultConstructor(X);
}
 
 
template<class T>
UObject* InternalVTableHelperCtorCaller(FVTableHelper& Helper)
{
    return T::__VTableCtorCaller(Helper);
}
 
COREUOBJECT_API void InitializePrivateStaticClass(
    class UClass* (*TClass_StaticClassFn)(),
    class UClass* TClass_Super_StaticClass,
    class UClass* TClass_PrivateStaticClass,
    class UClass* TClass_WithinClass_StaticClass,
    const TCHAR* PackageName,
    const TCHAR* Name
);
 
UE_DEPRECATED(5.6, "Use the new method above and specify UClass::StaticClass as the first argument")
COREUOBJECT_API void InitializePrivateStaticClass(
    class UClass* TClass_Super_StaticClass,
    class UClass* TClass_PrivateStaticClass,
    class UClass* TClass_WithinClass_StaticClass,
    const TCHAR* PackageName,
    const TCHAR* Name
    );
 
COREUOBJECT_API void GetPrivateStaticClassBody(
    const TCHAR* PackageName,
    const TCHAR* Name,
    UClass*& ReturnClass,
    void(*RegisterNativeFunc)(),
    uint32 InSize,
    uint32 InAlignment,
    EClassFlags InClassFlags,
    EClassCastFlags InClassCastFlags,
    const TCHAR* InConfigName,
    UClass::ClassConstructorType InClassConstructor,
    UClass::ClassVTableHelperCtorCallerType InClassVTableHelperCtorCaller,
    FUObjectCppClassStaticFunctions&& InCppClassStaticFunctions,
    UClass::StaticClassFunctionType InSuperClassFn,
    UClass::StaticClassFunctionType InWithinClassFn);
 
#if UE_WITH_CONSTINIT_UOBJECT
namespace UE::CodeGen::ConstInit
{
    struct FScriptStructParams
    {
        EStructFlags StructFlags; 
        UScriptStruct::ICppStructOps* StructOps;
    };
}
 
consteval UScriptStruct::UScriptStruct(
    UE::CodeGen::ConstInit::FObjectParams ObjectParams,
    UE::CodeGen::ConstInit::FUFieldParams FieldParams,
    UE::CodeGen::ConstInit::FStructParams StructParams,
    UE::CodeGen::ConstInit::FScriptStructParams Params
)
    : UStruct(ObjectParams, FieldParams, StructParams)
    , StructFlags(Params.StructFlags)
    , bPrepareCppStructOpsCompleted(false)
    , CppStructOps(Params.StructOps)
{
}
#endif // UE_WITH_CONSTINIT_UOBJECT
 
/*-----------------------------------------------------------------------------
    FObjectInstancingGraph.
-----------------------------------------------------------------------------*/
 
enum class EInstancePropertyValueFlags
{
    None                   = 0x00,
 
    // if set, then this property causes an instance to be created, otherwise this is just a pointer to a uobject that should be remapped if the object is instanced for some other property
    CausesInstancing       = 0x01,
 
    // if set, instance the reference to the subobjectroot, so far only delegates remap a self reference
    AllowSelfReference     = 0x02,
 
    // if set, then we do not create a new instance, but we will reassign one if there is already a mapping in the table
    DoNotCreateNewInstance = 0x04
};
 
ENUM_CLASS_FLAGS(EInstancePropertyValueFlags)
 
enum class EObjectInstancingGraphOptions
{
    None = 0x00,
 
    // if set, start with component instancing disabled
    DisableInstancing = 0x01,
 
    // if set, instance only subobject template values
    InstanceTemplatesOnly = 0x02,
};
 
ENUM_CLASS_FLAGS(EObjectInstancingGraphOptions)
 
struct FObjectInstancingGraph
{
public:
 
    COREUOBJECT_API explicit FObjectInstancingGraph(bool bDisableInstancing = false);
 
    COREUOBJECT_API explicit FObjectInstancingGraph(EObjectInstancingGraphOptions InOptions);
 
    COREUOBJECT_API explicit FObjectInstancingGraph( class UObject* DestinationSubobjectRoot, EObjectInstancingGraphOptions InOptions = EObjectInstancingGraphOptions::None);
 
    bool HasDestinationRoot() const
    {
        return GetDestinationRoot() != nullptr;
    }
 
    const UObject* GetDestinationRoot() const
    {
        return DestinationRoot;
    }
 
    COREUOBJECT_API void SetDestinationRoot( class UObject* DestinationSubobjectRoot, class UObject* InSourceRoot = nullptr );
 
    COREUOBJECT_API class UObject* GetDestinationObject(class UObject* SourceObject);
 
    COREUOBJECT_API class UObject* InstancePropertyValue( class UObject* SourceComponent, TNotNull<UObject*> CurrentValue, TNotNull<UObject*> Owner, EInstancePropertyValueFlags Flags = EInstancePropertyValueFlags::None );
 
    COREUOBJECT_API void AddNewObject(class UObject* ObjectInstance, class UObject* InArchetype = nullptr);
 
    COREUOBJECT_API void AddNewInstance(class UObject* ObjectInstance, class UObject* InArchetype = nullptr);
 
    COREUOBJECT_API void RetrieveObjectInstances( class UObject* SearchOuter, TArray<class UObject*>& out_Objects );
 
    template <typename Predicate>
    void ForEachObjectInstance(Predicate Pred)
    {
        for (TMap<UObject*, UObject*>::TIterator It(SourceToDestinationMap); It; ++It)
        {
            UObject* InstancedObject = It.Value();
            Pred(InstancedObject);
        }
    }
 
    void EnableSubobjectInstancing( bool bEnabled )
    {
        if (bEnabled)
        {
            InstancingOptions &= ~EObjectInstancingGraphOptions::DisableInstancing;
        }
        else
        {
            InstancingOptions |= EObjectInstancingGraphOptions::DisableInstancing;
        }
    }
 
    bool IsSubobjectInstancingEnabled() const
    {
        return !(InstancingOptions & EObjectInstancingGraphOptions::DisableInstancing);
    }
 
    void SetLoadingObject( bool bIsLoading )
    {
        bLoadingObject = bIsLoading;
    }
 
    void AddPropertyToSubobjectExclusionList(const FProperty* Property)
    {
        SubobjectInstantiationExclusionList.Add(Property);
    }
 
    bool IsPropertyInSubobjectExclusionList(const FProperty* Property) const
    {
        return SubobjectInstantiationExclusionList.Contains(Property);
    }
 
private:
    bool IsCreatingArchetype( bool bUserGeneratedOnly=true ) const
    {
        // if we only want cases where we are creating an archetype in response to user input, return false if we are in fact just loading the object from disk
        return bCreatingArchetype && (!bUserGeneratedOnly || !bLoadingObject);
    }
 
    bool IsLoadingObject() const
    {
        return bLoadingObject;
    }
 
    COREUOBJECT_API class UObject* GetInstancedSubobject( class UObject* SourceSubobject, class UObject* CurrentValue, class UObject* CurrentObject, EInstancePropertyValueFlags Flags );
 
    class       UObject*                        SourceRoot = nullptr;
 
    class       UObject*                        DestinationRoot = nullptr;
 
    EObjectInstancingGraphOptions               InstancingOptions = EObjectInstancingGraphOptions::None;
 
    bool                                        bCreatingArchetype = false;
 
    bool                                        bLoadingObject = false;
 
    TMap<class UObject*,class UObject*>         SourceToDestinationMap;
 
    TMap<class UObject*, class UObject*>        DestinationToSourceMap;
 
    TSet<const FProperty*>                      SubobjectInstantiationExclusionList;
};
 
Expose_TNameOf(FObjectInstancingGraph);
 
Expose_TNameOf(FObjectInstancingGraph*);
 
// UFunction interface.
 
inline UFunction* UFunction::GetSuperFunction() const
{
    UStruct* Result = GetSuperStruct();
    checkSlow(!Result || Result->IsA<UFunction>());
    return (UFunction*)Result;
}
 
 
// UObject.h
 
template<class T>
inline bool UObject::Implements() const
{
    UClass const* const MyClass = GetClass();
    return MyClass && MyClass->ImplementsInterface(T::StaticClass());
}
 
// UObjectGlobals.h
 
template< class T > 
inline const T* GetDefault(const UClass* Class)
{
    check(Class->GetDefaultObject()->IsA(T::StaticClass()));
    return (const T*)Class->GetDefaultObject();
}
 
template< class T > 
inline T* GetMutableDefault(UClass *Class)
{
    check(Class->GetDefaultObject()->IsA(T::StaticClass()));
    return (T*)Class->GetDefaultObject();
}
 
struct FStructUtils
{
    COREUOBJECT_API static bool ArePropertiesTheSame(const FProperty* A, const FProperty* B, bool bCheckPropertiesNames);
 
    COREUOBJECT_API static bool TheSameLayout(const UStruct* StructA, const UStruct* StructB, bool bCheckPropertiesNames = false);
 
    COREUOBJECT_API static UStruct* FindStructureInPackageChecked(const TCHAR* StructName, const TCHAR* PackageName);
 
#if !(UE_BUILD_TEST || UE_BUILD_SHIPPING)
    COREUOBJECT_API static int32 AttemptToFindUninitializedScriptStructMembers();
 
#if WITH_METADATA
    COREUOBJECT_API static int32 AttemptToFindShortTypeNamesInMetaData();
#endif // WITH_METADATA
#endif // !(UE_BUILD_TEST || UE_BUILD_SHIPPING)
};
 
/*-----------------------------------------------------------------------------
    Mirrors of mirror structures in Object.h. These are used by generated code 
    to facilitate correct offsets and alignments for structures containing these
    odd types.
-----------------------------------------------------------------------------*/
 
template <typename T, bool bHasStaticStruct = TModels_V<CStaticStructProvider, T>>
struct TBaseStructureBase
{
    static UScriptStruct* Get()
    {
        return T::StaticStruct();
    }
};
 
template <typename T>
struct TBaseStructureBase<T, false>
{
};
 
template <typename T>
struct TBaseStructure : TBaseStructureBase<T>
{
};
 
template<> struct TBaseStructure<FIntPoint> 
{
    static COREUOBJECT_API UScriptStruct* Get(); 
};
 
template<> struct TBaseStructure<FIntVector> 
{ 
    static COREUOBJECT_API UScriptStruct* Get(); 
};
 
template<> struct TBaseStructure<FInt64Vector2>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FIntVector4>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FLinearColor>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FColor>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FRandomStream>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FGuid>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FFallbackStruct>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurveFloat>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurveVector2D>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurveVector>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurveQuat>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurveTwoVectors>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurveLinearColor>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurvePointFloat>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurvePointVector2D>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurvePointVector>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurvePointQuat>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurvePointTwoVectors>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInterpCurvePointLinearColor>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FFloatRangeBound>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FFloatRange>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FDoubleRangeBound>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FDoubleRange>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInt32RangeBound>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInt32Range>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FFloatInterval>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FDoubleInterval>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FInt32Interval>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FFrameNumber;
 
template<> struct TBaseStructure<FFrameNumber>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FFrameTime;
 
template<> struct TBaseStructure<FFrameTime>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FFrameRate;
 
template<> struct TBaseStructure<FFrameRate>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FSoftObjectPath;
struct FSoftClassPath;
 
struct FPrimaryAssetType;
struct FPrimaryAssetId;
 
struct FDateTime;
 
template<> struct TBaseStructure<FDateTime>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FPolyglotTextData;
 
template<> struct TBaseStructure<FPolyglotTextData>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FAssetBundleData;
struct FTopLevelAssetPath;
 
template<> struct TBaseStructure<FRemoteObjectId>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<>
struct TStructOpsTypeTraits<FRemoteObjectId> : public TStructOpsTypeTraitsBase2<FRemoteObjectId>
{
    enum
    {
        WithNetSerializer = true,
        WithSerializer = true,
    };
};
 
struct FRemoteObjectTables;
template<> struct TBaseStructure<FRemoteObjectTables>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FRemoteObjectPathName;
template<> struct TBaseStructure<FRemoteObjectPathName>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FPackedRemoteObjectPathName;
template<> struct TBaseStructure<FPackedRemoteObjectPathName>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FRemoteObjectBytes;
template<> struct TBaseStructure<FRemoteObjectBytes>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
struct FRemoteObjectData;
template<> struct TBaseStructure<FRemoteObjectData>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<> struct TBaseStructure<FRemoteServerId>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
template<>
struct TStructOpsTypeTraits<FRemoteServerId> : public TStructOpsTypeTraitsBase2<FRemoteServerId>
{
    enum
    {
        WithNetSerializer = true,
        WithSerializer = true,
    };
};
 
struct FRemoteObjectReference;
template<> struct TBaseStructure<FRemoteObjectReference>
{
    static COREUOBJECT_API UScriptStruct* Get();
};
 
// TBaseStructure for explicit core variant types only. e.g. FVector3d returns "Vector3d" struct. 
template< class T > struct TVariantStructure
{
    static_assert(sizeof(T) == 0, "Unsupported for this type. Did you mean to use TBaseStructure?");
};
 
#define UE_DECLARE_CORE_VARIANT_TYPE(VARIANT, CORE)                                                     \
template<> struct TBaseStructure<::F##CORE> { COREUOBJECT_API static UScriptStruct* Get(); };           \
template<> struct TVariantStructure<::F##VARIANT##f> { COREUOBJECT_API static UScriptStruct* Get(); };  \
template<> struct TVariantStructure<::F##VARIANT##d> { COREUOBJECT_API static UScriptStruct* Get(); };
 
UE_DECLARE_CORE_VARIANT_TYPE(Vector2,   Vector2D);
UE_DECLARE_CORE_VARIANT_TYPE(Vector3,   Vector);
UE_DECLARE_CORE_VARIANT_TYPE(Vector4,   Vector4);
UE_DECLARE_CORE_VARIANT_TYPE(Plane4,    Plane);
UE_DECLARE_CORE_VARIANT_TYPE(Quat4,     Quat);
UE_DECLARE_CORE_VARIANT_TYPE(Rotator3,  Rotator);
UE_DECLARE_CORE_VARIANT_TYPE(Transform3,Transform);
UE_DECLARE_CORE_VARIANT_TYPE(Matrix44,  Matrix);
UE_DECLARE_CORE_VARIANT_TYPE(Box2,      Box2D);
UE_DECLARE_CORE_VARIANT_TYPE(Ray3,      Ray);
UE_DECLARE_CORE_VARIANT_TYPE(Sphere3, Sphere);
 
#undef UE_DECLARE_CORE_VARIANT_TYPE