Field.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
Field.h: Declares FField property system fundamentals
=============================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/LinkedListBuilder.h"
#include "Containers/Map.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformMath.h"
#include "HAL/PreprocessorHelpers.h"
#include "HAL/UnrealMemory.h"
#include "Internationalization/Text.h"
#include "Math/RandomStream.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Guid.h"
#include "Misc/Optional.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveAdapters.h"
#include "Serialization/StructuredArchiveSlots.h"
#include "Templates/EnableIf.h"
#include "Templates/IsAbstract.h"
#include "Templates/IsEnum.h"
#include "Templates/NoDestroy.h"
#include "Templates/Requires.h"
#include "Templates/TypeHash.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/CoreNative.h"
#include "UObject/GarbageCollection.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/PersistentObjectPtr.h"
#include "UObject/Script.h"
#include "UObject/SparseDelegate.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/WeakObjectPtr.h"
 
#include <type_traits>
 
class FField;
class FFieldVariant;
class FProperty;
class FReferenceCollector;
class UClass;
class UField;
class UPackage;
class UStruct;
 
class FFieldClass
{
public:
    using FConstructFunction = FField*(const FFieldVariant&, const FName&, EObjectFlags);
private:
    UE_NONCOPYABLE(FFieldClass);
 
    FName Name;
    EClassFlags ClassFlags;
    uint64 Id;
    EClassCastFlags CastFlags;
    FFieldClass* SuperClass;    
    FField* DefaultObject;
    FConstructFunction* ConstructFn;
    std::atomic<int32> UniqueNameIndexCounter = 0;
 
    COREUOBJECT_API FField* ConstructDefaultObject();
 
public:
 
    static COREUOBJECT_API TArray<FFieldClass*>& GetAllFieldClasses();
    static COREUOBJECT_API TMap<FName, FFieldClass*>& GetNameToFieldClassMap();
 
    COREUOBJECT_API explicit FFieldClass(const TCHAR* InCPPName, uint64 InId, EClassCastFlags InCastFlags, FFieldClass* InSuperClass, FConstructFunction* InConstructFn);
    COREUOBJECT_API ~FFieldClass();
 
    consteval explicit FFieldClass(
        EConstEval,
        const TCHAR* InCPPName,
        uint64 InId,
        EClassCastFlags InCastFlags,
        FFieldClass* InSuperClass,
        FConstructFunction* InConstructFn
    )
        : Name()
        , ClassFlags()
        , Id(InId)
        , CastFlags(InCastFlags)
        , SuperClass(InSuperClass)
        , DefaultObject()
        , ConstructFn(InConstructFn)
    {
    }
 
#if UE_WITH_CONSTINIT_UOBJECT
    bool IsFullyConstructed() const
    {
        return Name != FName();
    }
#endif
 
    inline FString GetName() const
    {
#if UE_WITH_CONSTINIT_UOBJECT
        checkSlow(IsFullyConstructed());
#endif
        return Name.ToString();
    }
    inline FName GetFName() const
    {
#if UE_WITH_CONSTINIT_UOBJECT
        checkSlow(IsFullyConstructed());
#endif
        return Name;
    }
    inline uint64 GetId() const
    {
        return Id;
    }
    inline uint64 GetCastFlags() const
    {
        return CastFlags;
    }
    inline bool HasAnyCastFlags(const uint64 InCastFlags) const
    {
        return !!(CastFlags & InCastFlags);
    }
    inline bool HasAllCastFlags(const uint64 InCastFlags) const
    {
        return (CastFlags & InCastFlags) == InCastFlags;
    }
    inline bool IsChildOf(const FFieldClass* InClass) const
    {
        const uint64 OtherClassId = InClass->GetId();
        return OtherClassId ? !!(CastFlags & OtherClassId) : IsChildOf_Walk(InClass);
    }
    COREUOBJECT_API FString GetDescription() const;
    COREUOBJECT_API FText GetDisplayNameText() const;
    FField* Construct(const FFieldVariant& InOwner, const FName& InName, EObjectFlags InFlags = RF_NoFlags) const
    {
        return ConstructFn(InOwner, InName, InFlags);
    }
 
    FFieldClass* GetSuperClass() const
    {
        return SuperClass;
    }
 
    FField* GetDefaultObject()
    {
        if (!DefaultObject)
        {
            DefaultObject = ConstructDefaultObject();
            check(DefaultObject);
        }
        return DefaultObject;
    }
 
    bool HasAnyClassFlags(EClassFlags FlagsToCheck) const
    {
        return EnumHasAnyFlags(ClassFlags, FlagsToCheck) != 0;
    }
 
    int32 GetNextUniqueNameIndex()
    {
        return ++UniqueNameIndexCounter;
    }
 
    friend FArchive& operator << (FArchive& Ar, FFieldClass& InField)
    {
        check(false);
        return Ar;
    }
    COREUOBJECT_API friend FArchive& operator << (FArchive& Ar, FFieldClass*& InOutFieldClass);
 
private:
    bool IsChildOf_Walk(const FFieldClass* InBaseClass) const
    {
        for (const FFieldClass* TempField = this; TempField; TempField = TempField->GetSuperClass())
        {
            if (TempField == InBaseClass)
            {
                return true;
            }
        }
        return false;
    }
 
#if UE_WITH_CONSTINIT_UOBJECT
    friend struct FRegisterFieldClass;
#endif // UE_WITH_CONSTINIT_UOBJECT
};
 
#if UE_WITH_CONSTINIT_UOBJECT
struct FRegisterFieldClass
{
    COREUOBJECT_API FRegisterFieldClass(FFieldClass* InFieldClass, const TCHAR* InCppName);
};
#endif // UE_WITH_CONSTINIT_UOBJECT
 
#if !CHECK_PUREVIRTUALS
    #define DECLARE_FIELD_NEW_IMPLEMENTATION(TClass) \
        ThisClass* Mem = (ThisClass*)FMemory::Malloc(InSize); \
        new (Mem) TClass(EC_InternalUseOnlyConstructor, TClass::StaticClass()); \
        return Mem; 
#else
    #define DECLARE_FIELD_NEW_IMPLEMENTATION(TClass) \
            ThisClass* Mem = (ThisClass*)FMemory::Malloc(InSize); \
            return Mem; 
#endif
 
#if UE_WITH_CONSTINIT_UOBJECT
#define UE_DEFINE_GET_FIELD_CLASS_PRIVATE virtual FFieldClass* GetFieldClassPrivate() override { return &ConstInitClass; }
#define UE_DECLARE_FIELD_CLASS_STATIC_CONSTINIT static constinit TNoDestroy<FFieldClass> ConstInitClass;
#define UE_DEFINE_FIELD_CLASS_STATIC_CONSTINIT(TClass)                                               \
    constinit TNoDestroy<FFieldClass> TClass::ConstInitClass{ NoDestroyConstEval,                    \
                                                              ConstEval,                             \
                                                              TEXT(PREPROCESSOR_TO_STRING(TClass)),  \
                                                              TClass::StaticClassCastFlagsPrivate(), \
                                                              TClass::StaticClassCastFlags(),        \
                                                              &TClass::Super::ConstInitClass,        \
                                                              &TClass::Construct };
#else
#define UE_DEFINE_GET_FIELD_CLASS_PRIVATE 
#define UE_DECLARE_FIELD_CLASS_STATIC_CONSTINIT 
#define UE_DEFINE_FIELD_CLASS_STATIC_CONSTINIT(...)
#endif
 
#define DECLARE_FIELD(TClass, TSuperClass, TStaticFlags) \
    DECLARE_FIELD_API(TClass, TSuperClass, TStaticFlags, NO_API)
 
#define DECLARE_FIELD_API(TClass, TSuperClass, TStaticFlags, TRequiredAPI) \
private: \
    TClass& operator=(TClass&&) = delete;   \
    TClass& operator=(const TClass&) = delete;   \
    UE_DEFINE_GET_FIELD_CLASS_PRIVATE \
public: \
    using Super = PREPROCESSOR_REMOVE_OPTIONAL_PARENS(TSuperClass);\
    using ThisClass = TClass;\
    TClass(EInternal InInernal, FFieldClass* InClass) \
        : Super(EC_InternalUseOnlyConstructor, InClass) \
    { \
    } \
    static TRequiredAPI FFieldClass* StaticClass(); \
    UE_DECLARE_FIELD_CLASS_STATIC_CONSTINIT \
    static TRequiredAPI FField* Construct(const FFieldVariant& InOwner, const FName& InName, EObjectFlags InObjectFlags); \
    inline static constexpr EClassCastFlags StaticClassCastFlagsPrivate() \
    { \
        return TStaticFlags; \
    } \
    inline static constexpr EClassCastFlags StaticClassCastFlags() \
    { \
        return TStaticFlags | Super::StaticClassCastFlags(); \
    } \
    inline void* operator new(const size_t InSize, void* InMem) \
    { \
        return InMem; \
    } \
    inline void* operator new(const size_t InSize) \
    { \
        DECLARE_FIELD_NEW_IMPLEMENTATION(TClass) \
    } \
    inline void operator delete(void* InMem) noexcept \
    { \
        FMemory::Free(InMem); \
    } \
    friend FArchive &operator<<( FArchive& Ar, ThisClass*& Res ) \
    { \
        return Ar << (FField*&)Res; \
    } \
    friend void operator<<(FStructuredArchive::FSlot InSlot, ThisClass*& Res) \
    { \
        InSlot << (FField*&)Res; \
    } \
    virtual SIZE_T GetFieldSize() const override \
    { \
        return sizeof(TClass); \
    }
 
#if !CHECK_PUREVIRTUALS
    #define IMPLEMENT_FIELD_CONSTRUCT_IMPLEMENTATION(TClass) \
        FField* Instance = new TClass(InOwner, InName, InFlags); \
        return Instance; 
#else
    #define IMPLEMENT_FIELD_CONSTRUCT_IMPLEMENTATION(TClass) \
        return nullptr;
#endif
 
#if UE_WITH_CONSTINIT_UOBJECT
#define IMPLEMENT_FIELD(TClass)                                                                        \
    FField* TClass::Construct(const FFieldVariant& InOwner, const FName& InName, EObjectFlags InFlags) \
    {                                                                                                  \
        IMPLEMENT_FIELD_CONSTRUCT_IMPLEMENTATION(TClass)                                               \
    }                                                                                                  \
    UE_DEFINE_FIELD_CLASS_STATIC_CONSTINIT(TClass)                                                     \
    static FRegisterFieldClass Register_FieldClass_##TClass(                                           \
        &TClass::ConstInitClass, TEXT(UE_STRINGIZE(TClass)));                                          \
    FFieldClass* TClass::StaticClass()                                                                 \
    {                                                                                                  \
        checkf(ConstInitClass->IsFullyConstructed(),                                                   \
            UE_STRINGIZE(TClass) TEXT(": FieldClass not fully constructed before ::StaticClass called")); \
        return &ConstInitClass;                                                                        \
    }
#else // UE_WITH_CONSTINIT_UOBJECT
#define IMPLEMENT_FIELD(TClass) \
FField* TClass::Construct(const FFieldVariant& InOwner, const FName& InName, EObjectFlags InFlags) \
{ \
    IMPLEMENT_FIELD_CONSTRUCT_IMPLEMENTATION(TClass) \
} \
FFieldClass* TClass::StaticClass() \
{ \
    static FFieldClass StaticFieldClass(TEXT(PREPROCESSOR_TO_STRING(TClass)), TClass::StaticClassCastFlagsPrivate(), TClass::StaticClassCastFlags(), TClass::Super::StaticClass(), &TClass::Construct); \
    return &StaticFieldClass; \
} 
#endif // UE_WITH_CONSTINIT_UOBJECT
 
class FField;
class FLinkerLoad;
class FProperty;
class UObject;
 
class FFieldVariant
{
    union FFieldObjectUnion
    {
        FField* Field;
        UObject* Object;
        UPTRINT Unknown;    
    } Container;
 
    static constexpr uintptr_t UObjectMask = 0x1;
 
    constexpr void ConditionallyMarkAsReachable()
    {
        UE_IF_NOT_CONSTEVAL
        {
            if (IsUObject() && ToUObjectUnsafe() && UE::GC::GIsIncrementalReachabilityPending)
            {
                UE::GC::MarkAsReachable(ToUObjectUnsafe());
            }
        }
    }
    
public:
 
    constexpr FFieldVariant()
    {
        Container.Field = nullptr;
    }
 
    FFieldVariant(const FField* InField)
    {
        Container.Field = const_cast<FField*>(InField);
        check(!IsUObject());
    }
 
#if UE_WITH_CONSTINIT_UOBJECT
    explicit consteval FFieldVariant(EConstEval, UObject* InObject)
    {
        // Object is not tagged here - when the engine starts up, pointers will be tagged during UObject bootstrap 
        Container.Object = InObject;
    }
 
    explicit consteval FFieldVariant(EConstEval, const FField* InField)
    {
        Container.Field = const_cast<FField*>(InField);
    }
#endif 
 
    template <
        typename T
        UE_REQUIRES(std::is_convertible_v<T, const UObject*>)
    >
    FFieldVariant(T&& InObject)
    {
        Container.Object = const_cast<UObject*>(ImplicitConv<const UObject*>(InObject));
        Container.Object = (UObject*)((uintptr_t)Container.Object | UObjectMask);
        ConditionallyMarkAsReachable();
    }
 
    constexpr FFieldVariant(TYPE_OF_NULLPTR)
        : FFieldVariant()
    {
    }
 
    constexpr FFieldVariant(const FFieldVariant& Other)
        : Container(Other.Container)
    {
        ConditionallyMarkAsReachable();
    }
    
    constexpr FFieldVariant& operator=(const FFieldVariant& Other)
    {
        Container = Other.Container;
        ConditionallyMarkAsReachable();
        return *this;
    }
    
    constexpr FFieldVariant(FFieldVariant&& Other)
        : Container(Other.Container)
    {
        ConditionallyMarkAsReachable();
    }
    
    constexpr FFieldVariant& operator=(FFieldVariant&& Other)
    {
        Container = Other.Container;
        ConditionallyMarkAsReachable();
        return *this;
    }
 
    inline bool IsUObject() const
    {
        return (uintptr_t)Container.Object & UObjectMask;
    }
    inline bool IsValid() const
    {
        return !!ToUObjectUnsafe();
    }
    COREUOBJECT_API bool IsValidLowLevel() const;
    inline operator bool() const
    {
        return IsValid();
    }
    COREUOBJECT_API bool IsA(const UClass* InClass) const;
    COREUOBJECT_API bool IsA(const FFieldClass* InClass) const;
    template <typename T>
    bool IsA() const
    {
        static_assert(sizeof(T) > 0, "T must not be an incomplete type");
        return IsA(T::StaticClass());
    }
 
    template <typename T>
    T* Get() const
    {
        static_assert(sizeof(T) > 0, "T must not be an incomplete type");
        if (IsA(T::StaticClass()))
        {
            if constexpr (std::is_base_of_v<UObject, T>)
            {
                return static_cast<T*>(ToUObjectUnsafe());
            }
            else
            {
                return static_cast<T*>(ToFieldUnsafe());
            }
        }
        return nullptr;
    }
 
    UObject* ToUObject() const
    {
        if (IsUObject())
        {
            return ToUObjectUnsafe();
        }
        else
        {
            return nullptr;
        }
    }
    FField* ToField() const
    {
        if (!IsUObject())
        {
            return ToFieldUnsafe();
        }
        else
        {
            return nullptr;
        }
    }
    UE_FORCEINLINE_HINT FField* ToFieldUnsafe() const
    {
        return Container.Field;
    }
    UE_FORCEINLINE_HINT UObject* ToUObjectUnsafe() const
    {
        return (UObject*)((uintptr_t)Container.Object & ~UObjectMask);
    }
 
    /* Return the raw value of the union without masking any tag bits away regardless of what type it is */
    void* GetRawPointer() const
    {
        return (void*)Container.Unknown;
    }
    COREUOBJECT_API FFieldVariant GetOwnerVariant() const;
    COREUOBJECT_API UClass* GetOwnerClass() const;
    COREUOBJECT_API FString GetFullName() const;
    COREUOBJECT_API FString GetPathName() const;
    COREUOBJECT_API FString GetName() const;
    COREUOBJECT_API FString GetClassName() const;
    COREUOBJECT_API FName GetFName() const;
    COREUOBJECT_API bool IsNative() const;
    COREUOBJECT_API UPackage* GetOutermost() const;
 
    bool operator==(const FFieldVariant& Other) const
    {
        return Container.Field == Other.Container.Field;
    }
    bool operator!=(const FFieldVariant& Other) const
    {
        return Container.Field != Other.Container.Field;
    }
 
#if WITH_METADATA
    COREUOBJECT_API bool HasMetaData(const FName& Key) const;
#endif // WITH_METADATA
 
    [[nodiscard]] friend uint32 GetTypeHash(const FFieldVariant& InFieldVariant)
    {
        return GetTypeHash(InFieldVariant.GetRawPointer());
    }
};
 
class FField
{
    UE_NONCOPYABLE(FField);
 
    union
    {
        FFieldClass* ClassPrivate;
#if UE_WITH_CONSTINIT_UOBJECT
        // Share storage for compiled-in name with ClassPrivate which can be re-acquired through the object's vtable at runtime
        // When there is a 4-byte solution for compiled-in FNames, this will be removed.
        const UTF8CHAR* NameTempUTF8;
#endif //UE_WITH_CONSTINIT_UOBJECT
    };
 
#if UE_WITH_CONSTINIT_UOBJECT
    virtual FFieldClass* GetFieldClassPrivate() PURE_VIRTUAL(FField::GetFieldClassPrivate, return nullptr;)
#endif
 
public:
    typedef FField Super;
    typedef FField ThisClass;
    typedef FField BaseFieldClass;  
    typedef FFieldClass FieldTypeClass;
 
    static COREUOBJECT_API FFieldClass* StaticClass();
#if UE_WITH_CONSTINIT_UOBJECT
    static constinit TNoDestroy<FFieldClass> ConstInitClass;
#endif // UE_WITH_CONSTINIT_UOBJECT
 
    virtual SIZE_T GetFieldSize() const
    {
        return sizeof(FField);
    }
 
    inline static constexpr EClassCastFlags StaticClassCastFlagsPrivate()
    {
        return CASTCLASS_UField;
    }
    inline static constexpr EClassCastFlags StaticClassCastFlags()
    {
        return CASTCLASS_UField;
    }
 
    FFieldVariant Owner;
 
    FField* Next;
 
    FName NamePrivate;
 
    EObjectFlags FlagsPrivate;
 
    // Constructors.
    COREUOBJECT_API FField(EInternal InInernal, FFieldClass* InClass);
    COREUOBJECT_API FField(FFieldVariant InOwner, const FName& InName, EObjectFlags InObjectFlags);
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API explicit FField(UField* InField);
#endif // WITH_EDITORONLY_DATA
    COREUOBJECT_API virtual ~FField();
 
#if UE_WITH_CONSTINIT_UOBJECT
    explicit consteval FField(EConstEval, FFieldClass* InFieldClass, UE::CodeGen::ConstInit::FFieldOwnerParam InOwner, FField* InNext, EObjectFlags InFlags, const UTF8CHAR* InNameUTF8)
    : NameTempUTF8(InNameUTF8)
    , Owner(InOwner.bIsObject ? FFieldVariant(ConstEval, InOwner.Value.Object) : FFieldVariant(ConstEval, InOwner.Value.Field))
    , Next(InNext)
    , NamePrivate()
    , FlagsPrivate(InFlags)
#if WITH_METADATA
    , MetaDataMap(nullptr)
#endif
    {
    }
#endif
 
    // Begin UObject interface: the following functions mimic UObject interface for easier transition from UProperties to FProperties
    COREUOBJECT_API virtual void Serialize(FArchive& Ar);
    COREUOBJECT_API virtual void PostLoad();
    COREUOBJECT_API virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps);
    COREUOBJECT_API virtual void BeginDestroy();    
    COREUOBJECT_API virtual void AddReferencedObjects(FReferenceCollector& Collector);
    COREUOBJECT_API bool IsRooted() const;
    COREUOBJECT_API bool IsNative() const;
    COREUOBJECT_API bool IsValidLowLevel() const;
    COREUOBJECT_API bool IsIn(const UObject* InOwner) const;
    COREUOBJECT_API bool IsIn(const FField* InOwner) const;
    COREUOBJECT_API FLinkerLoad* GetLinker() const; 
    // End UObject interface
 
    // Begin UField interface.
    COREUOBJECT_API virtual void AddCppProperty(FProperty* Property);
    COREUOBJECT_API virtual void Bind();
    // End UField interface
 
    static COREUOBJECT_API FField* Construct(const FFieldVariant& InOwner, const FName& InName, EObjectFlags InFlags);
    static COREUOBJECT_API FField* Construct(const FName& FieldTypeName, const FFieldVariant& InOwner, const FName& InName, EObjectFlags InFlags);
    static COREUOBJECT_API FField* TryConstruct(const FName& FieldTypeName, const FFieldVariant& InOwner, const FName& InName, EObjectFlags InFlags);
 
    COREUOBJECT_API virtual void PostDuplicate(const FField& InField);
 
#if UE_WITH_CONSTINIT_UOBJECT
    // For a const-initialized property, initialize the FName from a cached string and tag the owner pointer
    void InitializeConstInitField(FField* InOwner);
    void InitializeConstInitField(UObject* InOwner);
#endif
 
protected:
    void SetFlagsTo(EObjectFlags NewFlags)
    {
        checkfSlow((NewFlags & ~RF_AllFlags) == 0, TEXT("%s flagged as 0x%x but is trying to set flags to RF_AllFlags"), *GetFName().ToString(), (int32)FlagsPrivate);
        FlagsPrivate = NewFlags;
    }
public:
    EObjectFlags GetFlags() const
    {
        checkfSlow((FlagsPrivate & ~RF_AllFlags) == 0, TEXT("%s flagged as RF_AllFlags"), *GetFName().ToString());
        return FlagsPrivate;
    }
 
    void SetFlags(EObjectFlags NewFlags)
    {
        checkSlow(!(NewFlags & (RF_MarkAsNative | RF_MarkAsRootSet))); // These flags can't be used outside of constructors / internal code
        SetFlagsTo(GetFlags() | NewFlags);
    }
    void ClearFlags(EObjectFlags NewFlags)
    {
        checkSlow(!(NewFlags & (RF_MarkAsNative | RF_MarkAsRootSet)) || NewFlags == RF_AllFlags); // These flags can't be used outside of constructors / internal code
        SetFlagsTo(GetFlags() & ~NewFlags);
    }
    bool HasAnyFlags(EObjectFlags FlagsToCheck) const
    {
        checkSlow(!(FlagsToCheck & (RF_MarkAsNative | RF_MarkAsRootSet)) || FlagsToCheck == RF_AllFlags); // These flags can't be used outside of constructors / internal code
        return (GetFlags() & FlagsToCheck) != 0;
    }
    bool HasAllFlags(EObjectFlags FlagsToCheck) const
    {
        checkSlow(!(FlagsToCheck & (RF_MarkAsNative | RF_MarkAsRootSet)) || FlagsToCheck == RF_AllFlags); // These flags can't be used outside of constructors / internal code
        return ((GetFlags() & FlagsToCheck) == FlagsToCheck);
    }
 
    inline FFieldClass* GetClass() const
    {
        return ClassPrivate;
    }
    inline uint64 GetCastFlags() const
    {
        return GetClass()->GetCastFlags();
    }
 
    inline bool IsA(const FFieldClass* FieldType) const
    {
        check(FieldType);
        return GetClass()->IsChildOf(FieldType);
    }
 
    template<typename T>
    bool IsA() const
    {
        if constexpr (!!(T::StaticClassCastFlagsPrivate()))
        {
            return !!(GetCastFlags() & T::StaticClassCastFlagsPrivate());
        }
        else
        {
            return GetClass()->IsChildOf(T::StaticClass());
        }
    }
 
    UE_DEPRECATED(5.0, "HasAnyCastFlags is deprecated. Not all FField has CastFlag. Use IsA instead.")
    inline bool HasAnyCastFlags(const uint64 InCastFlags) const
    {
        return !!(GetCastFlags() & InCastFlags);
    }
 
    UE_DEPRECATED(5.0, "HasAllCastFlags is deprecated. Not all FField has CastFlag. Use IsA instead.")
    inline bool HasAllCastFlags(const uint64 InCastFlags) const
    {
        return (GetCastFlags() & InCastFlags) == InCastFlags;
    }
 
    void AppendName(FString& ResultString) const
    {
        GetFName().AppendString(ResultString);
    }
 
    FFieldVariant GetOwnerVariant() const
    {
        return Owner;
    }
 
    inline UObject* GetOwnerUObject() const
    {
        FFieldVariant TempOuter = Owner;
        while (!TempOuter.IsUObject() && TempOuter.IsValid())
        {
            // It's ok to use the 'Unsafe' variant of ToField here since we just checked IsUObject above
            TempOuter = TempOuter.ToFieldUnsafe()->Owner;
        }
        return TempOuter.ToUObject();
    }
 
    UE_FORCEINLINE_HINT UObject* InternalGetOwnerAsUObjectUnsafe() const
    {
        return Owner.ToUObjectUnsafe();
    }
 
    COREUOBJECT_API UClass* GetOwnerClass() const;
 
    COREUOBJECT_API UStruct* GetOwnerStruct() const;
 
    COREUOBJECT_API UField* GetOwnerUField() const;
 
    COREUOBJECT_API UPackage* GetOutermost() const;
 
    COREUOBJECT_API UObject* GetTypedOwner(UClass* Target) const;
 
    COREUOBJECT_API FField* GetTypedOwner(FFieldClass* Target) const;
 
    template <typename T>
    T* GetOwner() const
    {
        static_assert(sizeof(T) > 0, "T must not be an incomplete type");
        return Owner.Get<T>();
    }
 
    template <typename T>
    FUNCTION_NON_NULL_RETURN_START
    T* GetOwnerChecked() const
    FUNCTION_NON_NULL_RETURN_END
    {
        static_assert(sizeof(T) > 0, "T must not be an incomplete type");
        T* Result = Owner.Get<T>();
        check(Result);
        return Result;
    }
 
    template <typename T>
    T* GetTypedOwner() const
    {
        static_assert(sizeof(T) > 0, "T must not be an incomplete type");
        return static_cast<T*>(GetTypedOwner(T::StaticClass()));
    }
 
    inline FName GetFName() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        if (IsThisNotNull(this, "FField::GetFName"))
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        {
            return NamePrivate;
        }
        else
        {
            return NAME_None;
        }
    }
 
    inline FString GetName() const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        if (IsThisNotNull(this, "FField::GetName"))
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        {
            return NamePrivate.ToString();
        }
        else
        {
            return TEXT("None");
        }
    }
 
    inline void GetName(FString& OutName) const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        if (IsThisNotNull(this, "FField::GetName"))
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
        {
            return NamePrivate.ToString(OutName);
        }
        else
        {
            OutName = TEXT("None");
        }
    }
 
    COREUOBJECT_API void Rename(const FName& NewName);
 
    COREUOBJECT_API FString GetPathName(const UObject* StopOuter = nullptr) const;
    COREUOBJECT_API void GetPathName(const UObject* StopOuter, FStringBuilderBase& ResultString) const;
    COREUOBJECT_API FString GetFullName() const;
 
    COREUOBJECT_API FString GetAuthoredName() const;
 
    virtual FField* GetInnerFieldByName(const FName& InName)
    {
        return nullptr;
    }
 
    virtual void GetInnerFields(TArray<FField*>& OutFields)
    {
    }
 
#if WITH_METADATA
private:
    TMap<FName, FString>* MetaDataMap;
 
public:
    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 const FText GetMetaDataText(const TCHAR* MetaDataKey, const FTextKey LocalizationNamespace = FTextKey(), const FTextKey LocalizationKey = FTextKey()) const;
    COREUOBJECT_API const 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);
 
    COREUOBJECT_API void SetMetaData(const TCHAR* Key, FString&& InValue);
    COREUOBJECT_API void SetMetaData(const FName& Key, FString&& 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);
        // FString == operator does case insensitive comparison
        float Value = FCString::Atof(*FLOATString);
        return Value;
    }
    float GetFloatMetaData(const FName& Key) const
    {
        const FString& FLOATString = GetMetaData(Key);
        // FString == operator does case insensitive comparison
        float Value = FCString::Atof(*FLOATString);
        return Value;
    }
 
    double GetDoubleMetaData(const TCHAR* Key) const
    {
        const FString& DOUBLEString = GetMetaData(Key);
        // FString == operator does case insensitive comparison
        double Value = FCString::Atod(*DOUBLEString);
        return Value;
    }
    double GetDoubleMetaData(const FName& Key) const
    {
        const FString& DOUBLEString = GetMetaData(Key);
        // FString == operator does case insensitive comparison
        double Value = FCString::Atod(*DOUBLEString);
        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);
 
    COREUOBJECT_API const TMap<FName, FString>* GetMetaDataMap() const;
 
    COREUOBJECT_API void AppendMetaData(const TMap<FName, FString>& MetaDataMapToAppend);
 
    static COREUOBJECT_API void CopyMetaData(const FField* InSourceField, FField* InDestField);
#endif // WITH_METADATA
 
#if WITH_EDITORONLY_DATA
public:
    COREUOBJECT_API FString GetFullGroupName(bool bStartWithOuter) const;
 
    COREUOBJECT_API FText GetDisplayNameText() const;
 
    COREUOBJECT_API FText GetToolTipText(bool bShortTooltip = false) const;
 
    static COREUOBJECT_API FField* CreateFromUField(UField* InField);
    
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnConvertCustomUFieldToFField, FFieldClass*, UField*, FField*&);
    static COREUOBJECT_API FOnConvertCustomUFieldToFField& GetConvertCustomUFieldToFFieldDelegate();
#endif // WITH_EDITORONLY_DATA
 
public:
    static COREUOBJECT_API FField* Duplicate(const FField* InField, FFieldVariant DestOwner, const FName DestName = NAME_None, EObjectFlags FlagMask = RF_AllFlags, EInternalObjectFlags InternalFlagsMask = EInternalObjectFlags_AllFlags);
 
    static COREUOBJECT_API FName GenerateFFieldName(FFieldVariant InOwner, FFieldClass* InClass);
 
    using FLinkedListBuilder = TLinkedListBuilder<FField>;
};
 
// Support for casting between different FFIeld types
 
template<typename FieldType>
UE_FORCEINLINE_HINT FieldType* CastField(FField* Src)
{
    return Src && Src->IsA<FieldType>() ? static_cast<FieldType*>(Src) : nullptr;
}
 
template<typename FieldType>
UE_FORCEINLINE_HINT const FieldType* CastField(const FField* Src)
{
    return Src && Src->IsA<FieldType>() ? static_cast<const FieldType*>(Src) : nullptr;
}
 
template<typename FieldType>
UE_FORCEINLINE_HINT FieldType* ExactCastField(FField* Src)
{
    return (Src && (Src->GetClass() == FieldType::StaticClass())) ? static_cast<FieldType*>(Src) : nullptr;
}
 
template<typename FieldType>
UE_FORCEINLINE_HINT FieldType* ExactCastField(const FField* Src)
{
    return (Src && (Src->GetClass() == FieldType::StaticClass())) ? static_cast<const FieldType*>(Src) : nullptr;
}
 
template<typename FieldType>
FUNCTION_NON_NULL_RETURN_START
inline FieldType* CastFieldChecked(FField* Src)
FUNCTION_NON_NULL_RETURN_END
{
#if !DO_CHECK
    return (FieldType*)Src;
#else
    FieldType* CastResult = Src && Src->IsA<FieldType>() ? static_cast<FieldType*>(Src) : nullptr;
    checkf(CastResult, TEXT("CastFieldChecked failed with 0x%016llx"), (int64)(PTRINT)Src);
    return CastResult;
#endif // !DO_CHECK
}
 
template<typename FieldType>
FUNCTION_NON_NULL_RETURN_START
inline const FieldType* CastFieldChecked(const FField* Src)
FUNCTION_NON_NULL_RETURN_END
{
#if !DO_CHECK
    return (const FieldType*)Src;
#else
    const FieldType* CastResult = Src && Src->IsA<FieldType>() ? static_cast<const FieldType*>(Src) : nullptr;
    checkf(CastResult, TEXT("CastFieldChecked failed with 0x%016llx"), (int64)(PTRINT)Src);
    return CastResult;
#endif // !DO_CHECK
}
 
template<typename FieldType>
inline FieldType* CastFieldCheckedNullAllowed(FField* Src)
{
#if !DO_CHECK
    return (FieldType*)Src;
#else
    FieldType* CastResult = Src && Src->IsA<FieldType>() ? static_cast<FieldType*>(Src) : nullptr;
    checkf(CastResult || !Src, TEXT("CastFieldCheckedNullAllowed failed with 0x%016llx"), (int64)(PTRINT)Src);
    return CastResult;
#endif // !DO_CHECK
}
 
template<typename FieldType>
inline const FieldType* CastFieldCheckedNullAllowed(const FField* Src)
{
#if !DO_CHECK
    return (const FieldType*)Src;
#else
    const FieldType* CastResult = Src && Src->IsA<FieldType>() ? static_cast<const FieldType*>(Src) : nullptr;
    checkf(CastResult || !Src, TEXT("CastFieldCheckedNullAllowed failed with 0x%016llx"), (int64)(PTRINT)Src);
    return CastResult;
#endif // !DO_CHECK
}
 
template <typename FieldType>
inline void SerializeSingleField(FArchive& Ar, FieldType*& Field, FFieldVariant Owner)
{
    if (Ar.IsLoading())
    {
        FName PropertyTypeName;
        Ar << PropertyTypeName;
        if (PropertyTypeName != NAME_None)
        {
            Field = CastField<FieldType>(FField::Construct(PropertyTypeName, Owner, NAME_None, RF_NoFlags));
            check(Field);
            Field->Serialize(Ar);
        }
        else
        {
            Field = nullptr;
        }
    }
    else
    {
        FName PropertyTypeName = Field ? Field->GetClass()->GetFName() : NAME_None;     
        Ar << PropertyTypeName;
        if (Field)
        {
            Field->Serialize(Ar);
        }
    }
}
 
inline FName GetFNameSafe(const FField* InField)
{
    if (InField)
    {
        return InField->GetFName();
    }
    else
    {
        return NAME_None;
    }
}
inline FString GetNameSafe(const FField* InField)
{
    if (InField)
    {
        return InField->GetName();
    }
    else
    {
        return TEXT("none");
    }
}
COREUOBJECT_API FString GetFullNameSafe(const FField* InField);
COREUOBJECT_API FString GetPathNameSafe(const FField* InField, const UObject* StopOuter = nullptr);
COREUOBJECT_API FField* FindFPropertyByPath(const TCHAR* InFieldPath);
template <typename FieldType>
inline FieldType* FindFProperty(const TCHAR* InFieldPath)
{
    FField* FoundField = FindFPropertyByPath(InFieldPath);
    return CastField<FieldType>(FoundField);
}