BlueprintGeneratedClass.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Blueprint/BlueprintPropertyGuidProvider.h"
#include "CoreMinimal.h"
#include "Containers/IndirectArray.h"
#include "FieldNotificationId.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "UObject/Class.h"
#include "UObject/UnrealType.h"
#include "EdGraph/EdGraphPin.h"
#include "Containers/SortedMap.h"
 
#include "BlueprintGeneratedClass.generated.h"
 
class AActor;
class UActorComponent;
class UDynamicBlueprintBinding;
class UInheritableComponentHandler;
class UTimelineTemplate;
class UClassCookedMetaData;
class UEdGraphPin;
 
DECLARE_MEMORY_STAT_EXTERN(TEXT("Persistent Uber Graph Frame memory"), STAT_PersistentUberGraphFrameMemory, STATGROUP_Memory, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("BPComp Instancing Fast Path memory"), STAT_BPCompInstancingFastPathMemory, STATGROUP_Memory, );
 
USTRUCT()
struct FNodeToCodeAssociation
{
    GENERATED_USTRUCT_BODY()
 
public:
    TWeakObjectPtr<UEdGraphNode> Node;
    TWeakObjectPtr<UFunction> Scope;
    int32 Offset;
public:
    FNodeToCodeAssociation()
    : Node(nullptr)
    , Scope(nullptr)
    , Offset(0)
    {
    }
 
    FNodeToCodeAssociation(UEdGraphNode* InNode, UFunction* InFunction, int32 InOffset)
        : Node(InNode)
        , Scope(InFunction)
        , Offset(InOffset)
    {
    }
};
 
 
USTRUCT()
struct FDebuggingInfoForSingleFunction
{
    GENERATED_USTRUCT_BODY()
 
public:
    // Reverse map from code offset to source node
    TMap< int32, TWeakObjectPtr<UEdGraphNode> > LineNumberToSourceNodeMap;
 
    // Reverse map from code offset to source pin
    TMap< int32, FEdGraphPinReference > LineNumberToSourcePinMap;
 
    // Reverse map from source pin to mapped code offset(s)
    TMultiMap< FEdGraphPinReference, int32 > SourcePinToLineNumbersMap;
 
    // Map from source node (impure) to pure node script code range
    TMap< TWeakObjectPtr<UEdGraphNode>, FInt32Range > PureNodeScriptCodeRangeMap;
 
    // Reverse map from code offset to outer expansion (tunnel instance) source nodes
    TMap< int32, TArray<TWeakObjectPtr<UEdGraphNode> > > LineNumberToTunnelInstanceSourceNodesMap;
 
public:
    FDebuggingInfoForSingleFunction()
    {
    }
};
 
 
USTRUCT()
struct FPointerToUberGraphFrame
{
    GENERATED_USTRUCT_BODY()
 
public:
    uint8* RawPointer;
#if VALIDATE_UBER_GRAPH_PERSISTENT_FRAME
    uint32 UberGraphFunctionKey;
#endif//VALIDATE_UBER_GRAPH_PERSISTENT_FRAME
    // WARNING: This struct layout definition repeated in ScriptCore.cpp as
    // FPointerToUberGraphFrameCoreUObject to work around reflection generation issues
 
    FPointerToUberGraphFrame()
        : RawPointer(nullptr)
#if VALIDATE_UBER_GRAPH_PERSISTENT_FRAME
        , UberGraphFunctionKey(0)
#endif//VALIDATE_UBER_GRAPH_PERSISTENT_FRAME
    {}
 
    ~FPointerToUberGraphFrame()
    {
        // check(!RawPointer);
        // We don't want to check here because partially loaded blueprint classes may not be cleaned up properly. Re-enable if you are looking for specific ubergraph issues
    }
};
 
 
template<>
struct TStructOpsTypeTraits<FPointerToUberGraphFrame> : public TStructOpsTypeTraitsBase2<FPointerToUberGraphFrame>
{
    enum
    {
        WithZeroConstructor = true,
        WithCopy = false,
    };
};
 
 
// TSimpleRingBuffer
 
template<typename ElementType>
class TSimpleRingBuffer
{
public:
    TSimpleRingBuffer(int32 MaxItems)
        : WriteIndex(0)
    {
        Storage.Empty(MaxItems);
    }
 
    int32 Num() const
    {
        return Storage.Num();
    }
 
    ElementType& operator()(int32 i)
    {
        // First element is at WriteIndex-1, second at 2, etc...
        const int32 RingIndex = (WriteIndex - 1 - i);
        const int32 WrappedRingIndex = (RingIndex < 0) ? (RingIndex + ArrayMax()) : RingIndex;
 
        return Storage[WrappedRingIndex];
    }
 
    const ElementType& operator()(int32 i) const
    {
        // First element is at WriteIndex-1, second at 2, etc...
        const int32 RingIndex = (WriteIndex - 1 - i);
        const int32 WrappedRingIndex = (RingIndex < 0) ? (RingIndex + ArrayMax()) : RingIndex;
 
        return Storage[WrappedRingIndex];
    }
 
    int32 ArrayMax() const
    {
        return Storage.GetSlack() + Storage.Num();
    }
 
    // Note: Doesn't call the constructor on objects stored in it; make sure to properly initialize the memory returned by WriteNewElementUninitialized
    ElementType& WriteNewElementUninitialized()
    {
        const int32 OldWriteIndex = WriteIndex;
        WriteIndex = (WriteIndex + 1) % ArrayMax();
 
        if (Storage.GetSlack())
        {
            Storage.AddUninitialized(1);
        }
        return Storage[OldWriteIndex];
    }
 
    ElementType& WriteNewElementInitialized()
    {
        const int32 OldWriteIndex = WriteIndex;
        WriteIndex = (WriteIndex + 1) % ArrayMax();
 
        if (Storage.GetSlack())
        {
            Storage.Add(ElementType());
        }
        else
        {
            Storage[OldWriteIndex] = ElementType();
        }
        return Storage[OldWriteIndex];
    }
 
private:
    TArray<ElementType> Storage;
    int32 WriteIndex;
};
 
USTRUCT()
struct FBlueprintDebugData
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FBlueprintDebugData();
    ENGINE_API FBlueprintDebugData(FBlueprintDebugData&&);
    ENGINE_API FBlueprintDebugData(const FBlueprintDebugData&);
    ENGINE_API FBlueprintDebugData& operator=(FBlueprintDebugData&&);
    ENGINE_API FBlueprintDebugData& operator=(const FBlueprintDebugData&);
    ENGINE_API ~FBlueprintDebugData();
 
#if WITH_EDITORONLY_DATA
 
protected:
    // Lookup table from UUID to nodes that were allocated that UUID
    TMap<int32, TWeakObjectPtr<UEdGraphNode> > DebugNodesAllocatedUniqueIDsMap;
 
    // Lookup table from impure node to entry in DebugNodeLineNumbers
    TMultiMap<TWeakObjectPtr<UEdGraphNode>, int32> DebugNodeIndexLookup;
 
    // List of debug site information for each node that ended up contributing to codegen
    //   This contains a tracepoint for each impure node after all pure antecedent logic has executed but before the impure function call
    //   It does *not* contain the wire tracepoint placed after the impure function call
    TArray<struct FNodeToCodeAssociation> DebugNodeLineNumbers;
 
    // List of entry points that contributed to the ubergraph
    TMap<int32, FName> EntryPoints;
 
    // Acceleration structure for execution wire highlighting at runtime
    TMap<TWeakObjectPtr<UFunction>, FDebuggingInfoForSingleFunction> PerFunctionLineNumbers;
 
    // Map from objects to class properties they created
    TMap<TWeakObjectPtr<UObject>, TFieldPath<FProperty> > DebugObjectToPropertyMap;
 
    // Map from pins or nodes to class properties they created
    TMap<FEdGraphPinReference, TFieldPath<FProperty> > DebugPinToPropertyMap;
 
public:
 
    // Returns the UEdGraphNode associated with the UUID, or nullptr if there isn't one.
    ENGINE_API UEdGraphNode* FindNodeFromUUID(int32 UUID) const;
 
    ENGINE_API bool IsValid() const;
 
    // Finds the UEdGraphNode associated with the code location Function+CodeOffset, or nullptr if there isn't one
    ENGINE_API UEdGraphNode* FindSourceNodeFromCodeLocation(const UFunction* Function, int32 CodeOffset, bool bAllowImpreciseHit) const;
 
    // Finds the source pin associated with the code location Function+CodeOffset, or nullptr if there isn't one
    ENGINE_API UEdGraphPin* FindSourcePinFromCodeLocation(UFunction* Function, int32 CodeOffset) const;
 
    // Finds all code locations (Function+CodeOffset) associated with the source pin
    ENGINE_API void FindAllCodeLocationsFromSourcePin(UEdGraphPin const* SourcePin, UFunction* InFunction, TArray<int32>& OutPinToCodeAssociations) const;
 
    // Finds the first code location (Function+CodeOffset) associated with the source pin within the given range, or INDEX_NONE if there isn't one
    ENGINE_API int32 FindCodeLocationFromSourcePin(UEdGraphPin const* SourcePin, UFunction* InFunction, FInt32Range InRange = FInt32Range()) const;
 
    // Finds all code locations (Function+CodeOffset) associated with the source node
    ENGINE_API void FindAllCodeLocationsFromSourceNode(UEdGraphNode* SourceNode, UFunction* InFunction, TArray<int32>& OutNodeToCodeAssociations) const;
 
    // Finds the pure node script code range associated with the [impure] source node, or FInt32Range(INDEX_NONE) if there is no existing association
    ENGINE_API FInt32Range FindPureNodeScriptCodeRangeFromSourceNode(const UEdGraphNode* SourceNode, UFunction* InFunction) const;
 
    ENGINE_API const TArray<TWeakObjectPtr<UEdGraphNode> >* FindExpansionSourceNodesFromCodeLocation(UFunction* Function, int32 CodeOffset) const;
 
    // Finds the breakpoint injection site(s) in bytecode if any were associated with the given node
    ENGINE_API void FindBreakpointInjectionSites(UEdGraphNode* Node, TArray<uint8*>& InstallSites) const;
 
    // Looks thru the debugging data for any class variables associated with the node
    ENGINE_API FProperty* FindClassPropertyForPin(const UEdGraphPin* Pin) const;
 
    // Looks thru the debugging data for any class variables associated with the node (e.g., temporary variables or timelines)
    ENGINE_API FProperty* FindClassPropertyForNode(const UEdGraphNode* Node) const;
 
    // Adds a debug record for a source node and destination in the bytecode of a specified function
    ENGINE_API void RegisterNodeToCodeAssociation(UEdGraphNode* SourceNode, const TArray<TWeakObjectPtr<UEdGraphNode> >& ExpansionSourceNodes, UFunction* InFunction, int32 CodeOffset, bool bBreakpointSite);
 
    ENGINE_API void RegisterPureNodeScriptCodeRange(UEdGraphNode* SourceNode, UFunction* InFunction, FInt32Range InPureNodeScriptCodeRange);
 
    ENGINE_API void RegisterPinToCodeAssociation(UEdGraphPin const* SourcePin, UFunction* InFunction, int32 CodeOffset);
 
    ENGINE_API const TMap<int32, FName>& GetEntryPoints() const;
 
    ENGINE_API bool IsValidEntryPoint(const int32 LinkId) const;
 
    ENGINE_API void RegisterEntryPoint(const int32 ScriptOffset, const FName FunctionName);
 
    // Registers an association between an object (pin or node typically) and an associated class member property
    ENGINE_API void RegisterClassPropertyAssociation(class UObject* TrueSourceObject, class FProperty* AssociatedProperty);
 
    ENGINE_API void RegisterClassPropertyAssociation(const UEdGraphPin* TrueSourcePin, class FProperty* AssociatedProperty);
 
    // Registers an association between a UUID and a node
    ENGINE_API void RegisterUUIDAssociation(UEdGraphNode* TrueSourceNode, int32 UUID);
 
    // Returns the object that caused the specified property to be created (can return nullptr if the association is unknown)
    ENGINE_API UObject* FindObjectThatCreatedProperty(class FProperty* AssociatedProperty) const;
 
    // Returns the pin that caused the specified property to be created (can return nullptr if the association is unknown or the association is from an object instead)
    ENGINE_API UEdGraphPin* FindPinThatCreatedProperty(class FProperty* AssociatedProperty) const;
 
    ENGINE_API void GenerateReversePropertyMap(TMap<FProperty*, UObject*>& PropertySourceMap);
#endif
};
 
USTRUCT()
struct FEventGraphFastCallPair
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TObjectPtr<UFunction> FunctionToPatch = nullptr;
 
    UPROPERTY()
    int32 EventGraphCallOffset = 0;
};
 
USTRUCT()
struct FBlueprintComponentChangedPropertyInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FName PropertyName;
 
    UPROPERTY()
    int32 ArrayIndex;
 
    UPROPERTY()
    TObjectPtr<UStruct> PropertyScope;
 
    FBlueprintComponentChangedPropertyInfo()
    {
        ArrayIndex = 0;
        PropertyScope = nullptr;
    }
};
 
USTRUCT()
struct FBlueprintCookedComponentInstancingData
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TArray<struct FBlueprintComponentChangedPropertyInfo> ChangedPropertyList;
 
    UClass* ComponentTemplateClass;
 
    FName ComponentTemplateName;
 
    TEnumAsByte<EObjectFlags> ComponentTemplateFlags;
 
    UPROPERTY()
    bool bHasValidCookedData;
 
    FBlueprintCookedComponentInstancingData()
    {
        bHasValidCookedData = false;
        ComponentTemplateClass = nullptr;
        ComponentTemplateFlags = RF_NoFlags;
    }
 
    ENGINE_API ~FBlueprintCookedComponentInstancingData();
 
    ENGINE_API const FCustomPropertyListNode* GetCachedPropertyList() const;
 
    ENGINE_API void BuildCachedPropertyDataFromTemplate(UActorComponent* SourceTemplate);
 
    const TArray<uint8>& GetCachedPropertyData() const { return CachedPropertyData; }
 
protected:
    ENGINE_API void BuildCachedPropertyList(FCustomPropertyListNode** CurrentNode, const UStruct* CurrentScope, int32* CurrentSourceIdx = nullptr) const;
 
    ENGINE_API void BuildCachedArrayPropertyList(const FArrayProperty* ArraySubPropertyNode, FCustomPropertyListNode** CurrentNode, int32* CurrentSourceIdx) const;
 
private:
    mutable TIndirectArray<FCustomPropertyListNode> CachedPropertyListForSerialization;
 
    TArray<uint8> CachedPropertyData;
};
 
USTRUCT()
struct FBPComponentClassOverride
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FName ComponentName;
 
    UPROPERTY()
    TObjectPtr<const UClass> ComponentClass;
 
    FBPComponentClassOverride()
        : ComponentClass(nullptr)
    {
    }
 
    FBPComponentClassOverride(FName InComponentName, const UClass* InComponentClass)
        : ComponentName(InComponentName)
        , ComponentClass(InComponentClass)
    {
    }
 
    bool operator==(const FName OtherComponentName) const
    {
        return (ComponentName == OtherComponentName);
    }
};
 
UCLASS(NeedsDeferredDependencyLoading, MinimalAPI)
class UBlueprintGeneratedClass : public UClass, public IBlueprintPropertyGuidProvider
{
    GENERATED_UCLASS_BODY()
 
public:
 
    UPROPERTY(AssetRegistrySearchable)
    int32   NumReplicatedProperties;
 
    UPROPERTY()
    uint8 bHasCookedComponentInstancingData:1;
 
    UPROPERTY()
    uint8 bSupportsDynamicInstancedReference:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bIsSparseClassDataSerializable:1;
#endif // WITH_EDITORONLY_DATA
 
private:
    uint8 bCustomPropertyListForPostConstructionInitialized:1;
 
public:
    UPROPERTY()
    TArray<TObjectPtr<class UDynamicBlueprintBinding>> DynamicBindingObjects;
 
    UPROPERTY()
    TArray<TObjectPtr<class UActorComponent>> ComponentTemplates;
 
    UPROPERTY()
    TArray<TObjectPtr<class UTimelineTemplate>> Timelines;
 
    UPROPERTY()
    TArray<FBPComponentClassOverride> ComponentClassOverrides;
 
    UPROPERTY()
    TArray<FFieldNotificationId> FieldNotifies;
 
    int32 FieldNotifiesStartBitNumber = 0;
 
    UPROPERTY()
    TObjectPtr<class USimpleConstructionScript> SimpleConstructionScript;
 
    UPROPERTY()
    TObjectPtr<class UInheritableComponentHandler> InheritableComponentHandler;
    
    FStructProperty* UberGraphFramePointerProperty;
 
    UPROPERTY()
    TObjectPtr<UFunction> UberGraphFunction;
 
#if VALIDATE_UBER_GRAPH_PERSISTENT_FRAME
    uint32 UberGraphFunctionKey;
#endif//VALIDATE_UBER_GRAPH_PERSISTENT_FRAME
 
#if WITH_EDITORONLY_DATA
    // This is a list of event graph call function nodes that are simple (no argument) thunks into the event graph (typically used for animation delegates, etc...)
    // It is a deprecated list only used for backwards compatibility prior to VER_UE4_SERIALIZE_BLUEPRINT_EVENTGRAPH_FASTCALLS_IN_UFUNCTION.
    UPROPERTY()
    TArray<FEventGraphFastCallPair> FastCallPairs_DEPRECATED;
#endif
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    TObjectPtr<UObject> OverridenArchetypeForCDO;
 
    UPROPERTY()
    TMap<FName,FGuid> PropertyGuids;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<UFunction>> CalledFunctions;
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY()
    TMap<FName, FGuid> CookedPropertyGuids;
 
    // Mapping of changed properties & data to apply when instancing components in a cooked build (one entry per named AddComponent node template for fast lookup at runtime).
    // Note: This is not currently utilized by the editor; it is a runtime optimization for cooked builds only. It assumes that the component class structure does not change.
    UPROPERTY()
    TMap<FName, struct FBlueprintCookedComponentInstancingData> CookedComponentInstancingData;
 
    static ENGINE_API bool GetGeneratedClassesHierarchy(const UClass* InClass, TArray<const UBlueprintGeneratedClass*>& OutBPGClasses);
 
    static ENGINE_API bool ForEachGeneratedClassInHierarchy(const UClass* InClass, TFunctionRef<bool(const UBlueprintGeneratedClass*)> InFunc);
 
    ENGINE_API UInheritableComponentHandler* GetInheritableComponentHandler(const bool bCreateIfNecessary = false);
 
    ENGINE_API UActorComponent* FindComponentTemplateByName(const FName& TemplateName) const;
 
    static ENGINE_API void CreateComponentsForActor(const UClass* ThisClass, AActor* Actor);
    static ENGINE_API void CreateTimelineComponent(AActor* Actor, const UTimelineTemplate* TimelineTemplate);
 
    ENGINE_API void ForEachFieldNotify(TFunctionRef<bool(::UE::FieldNotification::FFieldId FieldId)> Callback, bool bIncludeSuper) const;
    ENGINE_API void InitializeFieldNotifies();
 
#if WITH_EDITOR
    ENGINE_API void ReinitializeObjectAfterCompile(UObject* Object) const;
    virtual void HandleReinitializeObjectAfterCompile(UObject* Object) const {}
 
    ENGINE_API virtual void PrepareToConformSparseClassData(UScriptStruct* SparseClassDataArchetypeStruct);
 
    ENGINE_API virtual void ConformSparseClassData(UObject* Object);
#endif
 
    //~ IBlueprintPropertyGuidProvider interface
    ENGINE_API virtual FName FindBlueprintPropertyNameFromGuid(const FGuid& PropertyGuid) const override final;
    ENGINE_API virtual FGuid FindBlueprintPropertyGuidFromName(const FName PropertyName) const override final;
    // End IBlueprintPropertyGuidProvider interface
 
    //~ UObject interface
    ENGINE_API virtual UE::Core::FVersePath GetVersePath() const override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps) override;
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
#if WITH_EDITOR
    ENGINE_API virtual void GetAdditionalAssetDataObjectsForCook(FArchiveCookContext& CookContext, 
        TArray<UObject*>& OutObjects) const override;
protected:
    ENGINE_API virtual void ThreadedPostLoadAssetRegistryTagsOverride(FPostLoadAssetRegistryTagsContext& Context) const;
public:
#endif //~ WITH_EDITOR
    ENGINE_API virtual FPrimaryAssetId GetPrimaryAssetId() const override;
    ENGINE_API virtual bool NeedsLoadForServer() const override;
    ENGINE_API virtual bool NeedsLoadForClient() const override;
    ENGINE_API virtual bool NeedsLoadForEditorGame() const override;
    ENGINE_API virtual bool CanBeClusterRoot() const override;
#if WITH_EDITOR
    ENGINE_API virtual UClass* RegenerateClass(UClass* ClassToRegenerate, UObject* PreviousCDO) override;
    ENGINE_API virtual void PreSaveRoot(FObjectPreSaveRootContext ObjectSaveContext) override;
    ENGINE_API virtual void PostSaveRoot(FObjectPostSaveRootContext ObjectSaveContext) override;
#endif  //~ WITH_EDITOR
    ENGINE_API virtual bool IsAsset() const override;
    //~ End UObject interface
 
    //~ UClass interface
#if WITH_EDITOR
    ENGINE_API virtual UClass* GetAuthoritativeClass() override;
    ENGINE_API virtual void ConditionalRecompileClass(FUObjectSerializeContext* InLoadContext) override;
    ENGINE_API virtual void FlushCompilationQueueForLevel() override;
    ENGINE_API virtual UObject* GetArchetypeForCDO() const override;
#endif //~ WITH_EDITOR
    ENGINE_API virtual void SerializeDefaultObject(UObject* Object, FStructuredArchive::FSlot Slot) override;
    ENGINE_API virtual void PostLoadDefaultObject(UObject* Object) override;
    ENGINE_API virtual bool IsFunctionImplementedInScript(FName InFunctionName) const override;
    ENGINE_API virtual uint8* GetPersistentUberGraphFrame(UObject* Obj, UFunction* FuncToCheck) const override;
    ENGINE_API virtual void CreatePersistentUberGraphFrame(UObject* Obj, bool bCreateOnlyIfEmpty = false, bool bSkipSuperClass = false, UClass* OldClass = nullptr) const override;
    ENGINE_API virtual void DestroyPersistentUberGraphFrame(UObject* Obj, bool bSkipSuperClass = false) const override;
    ENGINE_API virtual void Link(FArchive& Ar, bool bRelinkExistingProperties) override;
    ENGINE_API virtual void PurgeClass(bool bRecompilingOnLoad) override;
    ENGINE_API virtual void Bind() override;
    ENGINE_API virtual void GetDefaultObjectPreloadDependencies(TArray<UObject*>& OutDeps) override;
    ENGINE_API virtual UObject* FindArchetype(const UClass* ArchetypeClass, const FName ArchetypeName) const override;
 
    ENGINE_API virtual void InitPropertiesFromCustomList(uint8* DataPtr, const uint8* DefaultDataPtr) override;
    ENGINE_API virtual void SetupObjectInitializer(FObjectInitializer& ObjectInitializer) const override;
 
protected:
 
    ENGINE_API virtual FName FindPropertyNameFromGuid(const FGuid& PropertyGuid) const override;
    ENGINE_API virtual FGuid FindPropertyGuidFromName(const FName InName) const override;
    ENGINE_API virtual bool ArePropertyGuidsAvailable() const override;
    //~ End UClass interface
 
    const FCustomPropertyListNode* GetCustomPropertyListForPostConstruction() const
    {
        return CustomPropertyListForPostConstruction.Num() > 0 ? *CustomPropertyListForPostConstruction.GetData() : nullptr;
    }
 
    static ENGINE_API void InitPropertiesFromCustomList(const FCustomPropertyListNode* InPropertyList, UStruct* InStruct, uint8* DataPtr, const uint8* DefaultDataPtr);
 
    static ENGINE_API void InitArrayPropertyFromCustomList(const FArrayProperty* ArrayProperty, const FCustomPropertyListNode* InPropertyList, uint8* DataPtr, const uint8* DefaultDataPtr);
 
 
    static ENGINE_API bool InitPropertyFromSubPropertyList(const FProperty* Property, const FCustomPropertyListNode* SubPropertyList, uint8* PropertyValue, const uint8* DefaultPropertyValue);
 
public:
 
    ENGINE_API void UpdateCustomPropertyListForPostConstruction();
 
    static ENGINE_API void AddReferencedObjectsInUbergraphFrame(UObject* InThis, FReferenceCollector& Collector);
 
    static ENGINE_API FName GetUberGraphFrameName();
    static ENGINE_API bool UsePersistentUberGraphFrame();
 
    ENGINE_API bool UseFastPathComponentInstancing();
 
#if WITH_EDITORONLY_DATA
    FBlueprintDebugData DebugData;
 
 
    FBlueprintDebugData& GetDebugData()
    {
        return DebugData;
    }
 
    const FBlueprintDebugData& GetDebugData() const
    {
        return DebugData;
    }
#endif
 
    static ENGINE_API void BindDynamicDelegates(const UClass* ThisClass, UObject* InInstance);
 
    // Finds the desired dynamic binding object for this blueprint generated class
    static ENGINE_API UDynamicBlueprintBinding* GetDynamicBindingObject(const UClass* ThisClass, UClass* BindingClass);
 
#if WITH_EDITOR
    static ENGINE_API void UnbindDynamicDelegates(const UClass* ThisClass, UObject* InInstance);
 
    ENGINE_API void UnbindDynamicDelegatesForProperty(UObject* InInstance, const FObjectProperty* InObjectProperty);
#endif
 
    ENGINE_API virtual void GetLifetimeBlueprintReplicationList(TArray<class FLifetimeProperty>& OutLifetimeProps) const;
 
protected:
    ENGINE_API bool BuildCustomPropertyListForPostConstruction(FCustomPropertyListNode*& InPropertyList, UStruct* InStruct, const uint8* DataPtr, const uint8* DefaultDataPtr);
 
    ENGINE_API bool BuildCustomArrayPropertyListForPostConstruction(FArrayProperty* ArrayProperty, FCustomPropertyListNode*& InPropertyList, const uint8* DataPtr, const uint8* DefaultDataPtr, int32 StartIndex = 0);
 
private:
    TIndirectArray<FCustomPropertyListNode> CustomPropertyListForPostConstruction;
    FCriticalSection SerializeAndPostLoadCritical;
 
    using FEditorTags = TSortedMap<FName, FString, FDefaultAllocator, FNameFastLess>;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void GetEditorTags(FEditorTags& Tags) const;
 
    FEditorTags CookedEditorTags;
 
protected:
    ENGINE_API virtual TSubclassOf<UClassCookedMetaData> GetCookedMetaDataClass() const;
 
private:
    ENGINE_API UClassCookedMetaData* NewCookedMetaData();
    ENGINE_API const UClassCookedMetaData* FindCookedMetaData();
    ENGINE_API void PurgeCookedMetaData();
 
    UPROPERTY()
    TObjectPtr<UClassCookedMetaData> CachedCookedMetaDataPtr;
#endif // WITH_EDITORONLY_DATA
 
#if WITH_EDITORONLY_DATA
    TWeakObjectPtr<UScriptStruct> SparseClassDataPendingConformStruct = nullptr;
    void* SparseClassDataPendingConform = nullptr;
#endif // WITH_EDITORONLY_DATA
};