FieldPath.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SoftObjectPtr.h: Pointer to UObject asset, keeps extra information so that it is works even if the asset is not in memory
=============================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/ThreadSafeCounter.h"
#include "Misc/AssertionMacros.h"
#include "Templates/Requires.h"
#include "Templates/TypeHash.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Field.h"
#include "UObject/NameTypes.h"
#include "UObject/UObjectArray.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include <type_traits>
 
class FArchive;
class FLinkerLoad;
class UField;
class UStruct;
struct FUObjectItem;
template <typename T> struct TIsPODType;
template <typename T> struct TIsWeakPointerType;
template <typename T> struct TIsZeroConstructType;
 
struct FFieldPath
{
    friend struct FGCInternals;
 
    // TWeakFieldPtr needs access to ClearCachedField
    template<class T>
    friend struct TWeakFieldPtr;
 
    // FFieldPathProperty needs access to ConvertFromFullPath
    friend class FFieldPathProperty;
 
protected:
 
    /* Determines the behavior when resolving stored path */
    enum EPathResolveType
    {
        UseStructIfOuterNotFound = 0,
        UseStructAlways = 1
    };
 
    mutable FField* ResolvedField = nullptr;
#if WITH_EDITORONLY_DATA
    mutable FFieldClass* InitialFieldClass = nullptr;
    mutable int32 FieldPathSerialNumber = 0;
#endif
    mutable TWeakObjectPtr<UStruct> ResolvedOwner;
 
    TArray<FName> Path;
 
    inline bool NeedsResolving() const
    {
        if (ResolvedField)
        {
#if WITH_EDITORONLY_DATA
            UStruct* Owner = ResolvedOwner.Get();
            // In uncooked builds we also need to check if the serial number on the owner struct is identical
            // It will change if the struct has been recompiled or its properties have been destroyed
            if (Owner && IsFieldPathSerialNumberIdentical(Owner))
            {
                return false;
            }
#else
            // The assumption is that if we already resolved a field and its owner is still valid, there's no need to resolve again
            return !ResolvedOwner.IsValid();
#endif // WITH_EDITORONLY_DATA
        }
        return true;
    }
 
    inline void ClearCachedField() const
    {
        ResolvedField = nullptr;
#if WITH_EDITORONLY_DATA
        InitialFieldClass = nullptr;
        FieldPathSerialNumber = 0;
#endif // WITH_EDITORONLY_DATA
    }
 
private:
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API bool IsFieldPathSerialNumberIdentical(UStruct* InStruct) const;
    COREUOBJECT_API int32 GetFieldPathSerialNumber(UStruct* InStruct) const;
#endif
 
    UE_FORCEINLINE_HINT FUObjectItem* GetResolvedOwnerItemInternal()
    {
        return ResolvedOwner.Internal_GetObjectItem();
    }
    inline void ClearCachedFieldInternal()
    {
        ResolvedField = nullptr;
        ResolvedOwner.Reset();
    }
 
    COREUOBJECT_API UStruct* TryToResolveOwnerFromStruct(UStruct* InCurrentStruct = nullptr, EPathResolveType InResolveType = FFieldPath::UseStructIfOuterNotFound) const;
    
 
    COREUOBJECT_API UStruct* TryToResolveOwnerFromLinker(FLinkerLoad* InLinker) const;
 
 
    COREUOBJECT_API UStruct* ConvertFromFullPath(FLinkerLoad* InLinker);
 
public:
 
    FFieldPath() = default;
 
    FFieldPath(FField* InField)
    {
        Generate(InField);
    }
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API FFieldPath(UField* InField, const FName& InPropertyTypeName);
#endif
 
    COREUOBJECT_API void Generate(FField* InField);
 
    COREUOBJECT_API void Generate(const TCHAR* InFieldPathString);
 
#if WITH_EDITORONLY_DATA
    COREUOBJECT_API void GenerateFromUField(UField* InField);
#endif
 
    COREUOBJECT_API FField* TryToResolvePath(UStruct* InCurrentStruct, EPathResolveType InResolveType = FFieldPath::UseStructIfOuterNotFound) const;
 
    inline void ResolveField(FFieldClass* ExpectedClass = FField::StaticClass(), UStruct* InCurrentStruct = nullptr, EPathResolveType InResolveType = FFieldPath::UseStructIfOuterNotFound) const
    {
        FField* FoundField = TryToResolvePath(InCurrentStruct, InResolveType);
        if (FoundField && FoundField->IsA(ExpectedClass) 
#if WITH_EDITORONLY_DATA
            && (!InitialFieldClass || FoundField->IsA(InitialFieldClass))
#endif // WITH_EDITORONLY_DATA
            )
        {
            ResolvedField = FoundField;
#if WITH_EDITORONLY_DATA
            if (!InitialFieldClass)
            {
                InitialFieldClass = FoundField->GetClass();
            }
            UStruct* Owner = ResolvedOwner.Get();
            check(Owner);
            FieldPathSerialNumber = GetFieldPathSerialNumber(Owner);
#endif // WITH_EDITORONLY_DATA
        }
        else if (ResolvedField)
        {
            // In case this field has been previously resolved, clear the owner as well as it's impossible the original field
            // will ever come back (it's most likely been deleted) and we don't want to resolve to a newly created one even if its name and class match
            ResolvedOwner.Reset();
            ResolvedField = nullptr;
        }
    }
 
    inline FField* GetTyped(FFieldClass* ExpectedType, UStruct* InCurrentStruct = nullptr) const
    {
        if (NeedsResolving() && Path.Num())
        {
            ResolveField(ExpectedType, InCurrentStruct, FFieldPath::UseStructIfOuterNotFound);
        }
        return ResolvedField;
    }
 
    inline bool IsPathToFieldEmpty() const
    {
        return !Path.Num();
    }
 
    inline bool IsStale() const
    {
        return ResolvedField && (!ResolvedOwner.IsValid()
#if WITH_EDITORONLY_DATA
            || !IsFieldPathSerialNumberIdentical(ResolvedOwner.Get())
#endif // WITH_EDITORONLY_DATA
            );
    }
 
    inline void Reset()
    {
        ClearCachedField();
        ResolvedOwner.Reset();
        Path.Empty();
    }
 
    UE_FORCEINLINE_HINT bool operator==(const FFieldPath& InOther) const
    {
        return ResolvedOwner == InOther.ResolvedOwner && Path == InOther.Path;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(const FFieldPath& InOther) const
    {
        return ResolvedOwner != InOther.ResolvedOwner || Path != InOther.Path;
    }
 
    COREUOBJECT_API FString ToString() const;
 
    COREUOBJECT_API friend FArchive& operator<<(FArchive& Ar, FFieldPath& InOutPropertyPath);
 
    [[nodiscard]] inline friend uint32 GetTypeHash(const FFieldPath& InPropertyPath)
    {
        uint32 HashValue = 0;
        for (const FName& PathSegment : InPropertyPath.Path)
        {
            HashValue = HashCombine(HashValue, GetTypeHash(PathSegment));
        }
        return HashValue;
    }
};
 
template<class PropertyType>
struct TFieldPath : public FFieldPath
{
private:
 
    // These exists only to disambiguate the two constructors below
    enum EDummy1 { Dummy1 };
 
public:
    TFieldPath()
    {}
    inline TFieldPath(const TFieldPath& Other)
    {
        //  First refresh the serial number from the other path
        Other.Get();
        // Now that the Other path is refreshed, we can copy from it
        FFieldPath::operator=(Other);
    }
    inline TFieldPath& operator=(const TFieldPath& Other)
    {
        //  First refresh the serial number from the other path
        Other.Get();
        // Now that the Other path is refreshed, we can copy from it
        FFieldPath::operator=(Other);
        return *this;
    }
 
    UE_FORCEINLINE_HINT TFieldPath(TYPE_OF_NULLPTR)
        : FFieldPath()
    {
    }
 
    inline TFieldPath(const TCHAR* InPath)
        : FFieldPath()
    {
        Generate(InPath);
    }
 
#if WITH_EDITORONLY_DATA
    TFieldPath(UField* InField)
        : FFieldPath(InField, PropertyType::StaticClass()->GetFName())
    {
        // This static assert is in here rather than in the body of the class because we want
        // to be able to define TWeakFieldPtr<UUndefinedClass>.
        static_assert(std::is_convertible_v<PropertyType*, const volatile FField*>, "TFieldPath can only be constructed with FField types");
    }
#endif
 
    template <
        typename OtherPropertyType
        UE_REQUIRES(std::is_convertible_v<OtherPropertyType*, PropertyType*>)
    >
    inline TFieldPath(OtherPropertyType* InProperty, EDummy1 = Dummy1)
        : FFieldPath((FField*)CastField<PropertyType>(InProperty))
    {
        // This static assert is in here rather than in the body of the class because we want
        // to be able to define TFieldPath<UUndefinedClass>.
        static_assert(std::is_convertible_v<PropertyType*, const volatile FField*>, "TFieldPath can only be constructed with FField types");
    }
 
    template <
        typename OtherPropertyType
        UE_REQUIRES(std::is_convertible_v<OtherPropertyType*, PropertyType*>)
    >
    inline TFieldPath(const TFieldPath<OtherPropertyType>& Other)
        : FFieldPath(Other)
    {
        // This static assert is in here rather than in the body of the class because we want
        // to be able to define TFieldPath<UUndefinedClass>.
        static_assert(std::is_convertible_v<PropertyType*, const volatile FField*>, "TFieldPath can only be constructed with FField types");
    }
 
    template <
        typename OtherPropertyType
        UE_REQUIRES(std::is_convertible_v<OtherPropertyType*, PropertyType*>)
    >
    inline void operator=(OtherPropertyType* InProperty)
    {
        // This (FField*) cast is effectively a const_cast, as we've already validated the convertibility in the
        // constraint, and that PropertyType is an FField type in the constructors.
        ResolvedField = (FField*)InProperty; 
        Generate(ResolvedField);
    }
 
    template <
        typename OtherPropertyType
        UE_REQUIRES(std::is_convertible_v<OtherPropertyType*, PropertyType*>)
    >
    inline void operator=(const TFieldPath<OtherPropertyType>& Other)
    {
        // First make sure the Other path has the serial number up to date, otherwise we'll keep having to
        // reevealuate this path because it gets the serial number copied from the Other path
        Other.Get();
        // Now that the Other path is refreshed, we can copy from it
        FFieldPath::operator=(Other);
    }
 
    UE_FORCEINLINE_HINT PropertyType* Get(UStruct* InCurrentStruct = nullptr) const
    {
        return (PropertyType*)GetTyped(PropertyType::StaticClass(), InCurrentStruct);
    }
 
    inline PropertyType* ResolveWithRenamedStructPackage(UStruct* InCurrentStruct)
    {
        ClearCachedField();
        ResolveField(PropertyType::StaticClass(), InCurrentStruct, FFieldPath::UseStructAlways);
        return static_cast<PropertyType*>(ResolvedField);
    }
 
    UE_FORCEINLINE_HINT PropertyType* operator*() const
    {
        return Get();
    }
 
    UE_FORCEINLINE_HINT PropertyType* operator->() const
    {
        return Get();
    }
};
 
template <typename LhsType, typename RhsType>
UE_FORCEINLINE_HINT auto operator==(const TFieldPath<LhsType>& Lhs, const TFieldPath<LhsType>& Rhs)
    -> decltype((LhsType*)nullptr == (RhsType*)nullptr)
{
    return *(const FFieldPath*)&Lhs == *(const FFieldPath*)&Rhs;
}
 
template <typename LhsType, typename RhsType>
UE_FORCEINLINE_HINT auto operator==(const TFieldPath<LhsType>& Lhs, const RhsType* Rhs)
    -> decltype((LhsType*)nullptr == Rhs)
{
    return Lhs.Get() == Rhs;
}
 
template <typename LhsType, typename RhsType>
UE_FORCEINLINE_HINT auto operator==(const LhsType* Lhs, const TFieldPath<RhsType>& Rhs)
    -> decltype(Lhs == (RhsType*)nullptr)
{
    return Lhs == Rhs.Get();
}
 
template <typename LhsType>
UE_FORCEINLINE_HINT bool operator==(TFieldPath<LhsType>& Lhs, TYPE_OF_NULLPTR)
{
    return !Lhs.Get();
}
 
template <typename RhsType>
UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR, TFieldPath<RhsType>& Rhs)
{
    return !Rhs.Get();
}
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
template <typename LhsType, typename RhsType>
UE_FORCEINLINE_HINT auto operator!=(const TFieldPath<LhsType>& Lhs, const TFieldPath<LhsType>& Rhs)
    -> decltype((LhsType*)nullptr != (RhsType*)nullptr)
{
    return !(Lhs == Rhs);
}
 
template <typename LhsType, typename RhsType>
UE_FORCEINLINE_HINT auto operator!=(const TFieldPath<LhsType>& Lhs, const RhsType* Rhs)
    -> decltype((LhsType*)nullptr != Rhs)
{
    return !(Lhs == Rhs);
}
 
template <typename LhsType, typename RhsType>
UE_FORCEINLINE_HINT auto operator!=(const LhsType* Lhs, const TFieldPath<RhsType>& Rhs)
    -> decltype(Lhs != (RhsType*)nullptr)
{
    return !(Lhs == Rhs);
}
 
template <typename LhsType>
UE_FORCEINLINE_HINT bool operator!=(TFieldPath<LhsType>& Lhs, TYPE_OF_NULLPTR)
{
    return !(Lhs == nullptr);
}
 
template <typename RhsType>
UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR, TFieldPath<RhsType>& Rhs)
{
    return !(nullptr == Rhs);
}
#endif
 
// Helper function which deduces the type of the initializer
template <typename PropertyType>
UE_FORCEINLINE_HINT TFieldPath<PropertyType> MakePropertyPath(PropertyType* Ptr)
{
    return TFieldPath<PropertyType>(Ptr);
}
 
 
template<class T> struct TIsPODType<TFieldPath<T> > { enum { Value = true }; };
template<class T> struct TIsZeroConstructType<TFieldPath<T> > { enum { Value = true }; };
template<class T> struct TIsWeakPointerType<TFieldPath<T> > { enum { Value = true }; };
 
 
template <typename KeyType, typename ValueType, bool bInAllowDuplicateKeys = false>
struct TPropertyPathMapKeyFuncs : public TDefaultMapKeyFuncs<KeyType, ValueType, bInAllowDuplicateKeys>
{
    typedef typename TDefaultMapKeyFuncs<KeyType, ValueType, bInAllowDuplicateKeys>::KeyInitType KeyInitType;
 
    static UE_FORCEINLINE_HINT bool Matches(KeyInitType A, KeyInitType B)
    {
        return A == B;
    }
 
    static UE_FORCEINLINE_HINT uint32 GetKeyHash(KeyInitType Key)
    {
        return GetTypeHash(Key);
    }
};