PropertyPathHelpers.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
#include "Misc/AssertionMacros.h"
#include "PropertyTypeCompatibility.h"
#include "UObject/Class.h"
#include "UObject/Field.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/UnrealType.h"
 
#include "PropertyPathHelpers.generated.h"
 
class FArchive;
template <typename FuncType> class TFunctionRef;
 
USTRUCT()
struct FPropertyPathSegment
{
    GENERATED_BODY()
 
    friend struct FCachedPropertyPath;
 
    PROPERTYPATH_API FPropertyPathSegment();
 
    PROPERTYPATH_API FPropertyPathSegment(int32 InCount, const TCHAR* InString);
 
    PROPERTYPATH_API void PostSerialize(const FArchive& Ar);
 
    static PROPERTYPATH_API FPropertyPathSegment MakeUnresolvedCopy(const FPropertyPathSegment& ToCopy);
 
    PROPERTYPATH_API FFieldVariant Resolve(UStruct* InStruct) const;
 
    PROPERTYPATH_API FName GetName() const;
 
    PROPERTYPATH_API int32 GetArrayIndex() const;
 
    PROPERTYPATH_API FFieldVariant GetField() const;
 
    PROPERTYPATH_API UStruct* GetStruct() const;
 
public:
 
    UPROPERTY()
    FName Name;
 
    UPROPERTY()
    int32 ArrayIndex;
 
private:
 
    UPROPERTY(Transient)
    mutable TObjectPtr<UStruct> Struct;
 
    mutable FFieldVariant Field;
};
 
template<>
struct TStructOpsTypeTraits<FPropertyPathSegment> : TStructOpsTypeTraitsBase2<FPropertyPathSegment>
{
    enum { WithPostSerialize = true };
};
 
USTRUCT()
struct FCachedPropertyPath
{
    GENERATED_BODY()
 
    
    PROPERTYPATH_API FCachedPropertyPath();
 
    PROPERTYPATH_API FCachedPropertyPath(const FString& Path);
 
    PROPERTYPATH_API FCachedPropertyPath(const FPropertyPathSegment& Segment);
 
    PROPERTYPATH_API FCachedPropertyPath(const TArray<FString>& PathSegments);
 
    PROPERTYPATH_API FCachedPropertyPath(const FPropertyChangedChainEvent& PropertyChangedChainEvent);
    PROPERTYPATH_API FCachedPropertyPath(const FPropertyChangedEvent& PropertyChangedEvent, const FEditPropertyChain& PropertyChain);
 
    PROPERTYPATH_API ~FCachedPropertyPath();
 
    bool IsValid() const { return Segments.Num() > 0; }
 
    PROPERTYPATH_API void MakeFromString(const FString& InPropertyPath);
 
    PROPERTYPATH_API void MakeFromChangeEvent(const FPropertyChangedChainEvent& PropertyChangedChainEvent);
    PROPERTYPATH_API void MakeFromChangeEvent(const FPropertyChangedEvent& PropertyChangedEvent, const FEditPropertyChain& PropertyChain);
 
    static PROPERTYPATH_API FCachedPropertyPath MakeUnresolvedCopy(const FCachedPropertyPath& ToCopy);
 
    PROPERTYPATH_API FCachedPropertyPath MakeParentPath() const;
 
    PROPERTYPATH_API int32 GetNumSegments() const;
 
    PROPERTYPATH_API const FPropertyPathSegment& GetSegment(int32 InSegmentIndex) const;
 
    PROPERTYPATH_API const FPropertyPathSegment& GetLastSegment() const;
 
    PROPERTYPATH_API bool Resolve(UObject* InContainer) const;
 
    PROPERTYPATH_API void SetCanSafelyUsedCachedAddress(bool bInCanSafelyUsedCachedAddress) const;
 
    PROPERTYPATH_API void SetCachedLastContainer(void* InContainer, int32 InIndex) const;
 
    PROPERTYPATH_API void* GetCachedLastContainerInPath() const;
 
    PROPERTYPATH_API int32 GetCachedLastContainerInPathIndex() const;
 
    PROPERTYPATH_API void ResolveLeaf(void* InAddress) const;
 
    PROPERTYPATH_API void ResolveLeaf(UFunction* InFunction) const;
 
    PROPERTYPATH_API bool IsResolved() const;
 
    PROPERTYPATH_API bool IsFullyResolved() const;
 
    PROPERTYPATH_API void* GetCachedAddress() const;
 
    PROPERTYPATH_API UFunction* GetCachedFunction() const;
 
    PROPERTYPATH_API FPropertyChangedEvent ToPropertyChangedEvent(EPropertyChangeType::Type InChangeType) const;
 
    PROPERTYPATH_API void ToEditPropertyChain(FEditPropertyChain& OutPropertyChain) const;
 
    PROPERTYPATH_API FString ToString() const;
 
    PROPERTYPATH_API bool operator==(const FString& Other) const;
 
    PROPERTYPATH_API bool Equals(const FString& Other) const;
 
    PROPERTYPATH_API void* GetCachedContainer() const;
 
    PROPERTYPATH_API void SetCachedContainer(void* InContainer) const;
 
    PROPERTYPATH_API void RemoveFromEnd(int32 InNumSegments = 1);
 
    PROPERTYPATH_API void RemoveFromStart(int32 InNumSegments = 1);
 
    PROPERTYPATH_API FProperty* GetFProperty() const;
private:
    UPROPERTY()
    TArray<FPropertyPathSegment> Segments;
 
    mutable void* CachedAddress;
 
    UPROPERTY()
    mutable TObjectPtr<UFunction> CachedFunction;
 
    mutable void* CachedContainer;
 
    mutable void* CachedLastContainerInPath;
 
    mutable int32 CachedLastContainerInPathIndex;
 
    mutable bool bCanSafelyUsedCachedAddress;
};
 
namespace PropertyPathHelpersInternal
{
    struct FPropertyPathResolver;
    struct FPropertyStructView;
    template<typename T> struct FInternalGetterResolver;
    template<typename T> struct FInternalSetterResolver;
 
    PROPERTYPATH_API bool ResolvePropertyPath(UObject* InContainer, const FString& InPropertyPath, FPropertyPathResolver& InResolver);
    PROPERTYPATH_API bool ResolvePropertyPath(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, FPropertyPathResolver& InResolver);
    PROPERTYPATH_API bool ResolvePropertyPath(void* InContainer, UStruct* InStruct, const FString& InPropertyPath, FPropertyPathResolver& InResolver);
    PROPERTYPATH_API bool ResolvePropertyPath(void* InContainer, UStruct* InStruct, const FCachedPropertyPath& InPropertyPath, FPropertyPathResolver& InResolver);
    template<typename T, typename ContainerType> bool GetValueFast(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, T& OutValue, FProperty*& OutProperty);
    template<typename T, typename ContainerType> bool SetValueFast(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, const T& InValue);
}
 
namespace PropertyPathHelpers
{
    PROPERTYPATH_API bool GetPropertyValueAsString(UObject* InContainer, const FString& InPropertyPath, FString& OutValue, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool GetPropertyValueAsString(UObject* InContainer, const FString& InPropertyPath, FString& OutValue, FProperty*& OutProperty, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool GetPropertyValueAsString(void* InContainer, UStruct* InStruct, const FString& InPropertyPath, FString& OutValue, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool GetPropertyValueAsString(void* InContainer, UStruct* InStruct, const FString& InPropertyPath, FString& OutValue, FProperty*& OutProperty, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool GetPropertyValueAsString(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, FString& OutValue, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool GetPropertyValueAsString(void* InContainer, UStruct* InStruct, const FCachedPropertyPath& InPropertyPath, FString& OutValue, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool SetPropertyValueFromString(UObject* InContainer, const FString& InPropertyPath, const FString& InValue, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool SetPropertyValueFromString(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, const FString& InValue, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool SetPropertyValueFromString(void* InContainer, UStruct* InStruct, const FString& InPropertyPath, const FString& InValue, uint32 PPF_Flags = PPF_None);
 
    PROPERTYPATH_API bool SetPropertyValueFromString(void* InContainer, UStruct* InStruct, const FCachedPropertyPath& InPropertyPath, const FString& InValue, uint32 PPF_Flags = PPF_None);
 
    template<typename T>
    bool GetPropertyValueFast(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, T& OutValue)
    {
        FProperty* OutProperty;
        return GetPropertyValueFast<T>(InContainer, InPropertyPath, OutValue, OutProperty);
    }
 
    template<typename T>
    bool GetPropertyValueFast(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, T& OutValue, FProperty*& OutProperty)
    {
        check(InContainer);
        check(InContainer == InPropertyPath.GetCachedContainer());
        check(InPropertyPath.IsResolved());
 
        return PropertyPathHelpersInternal::GetValueFast<T>(InContainer, InPropertyPath, OutValue, OutProperty);
    }
 
    template<typename T>
    bool GetPropertyValue(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, T& OutValue, FProperty*& OutProperty)
    {
        check(InContainer);
 
        if(InPropertyPath.IsFullyResolved())
        {
            return GetPropertyValueFast<T>(InContainer, InPropertyPath, OutValue, OutProperty);
        }
        else
        {
            PropertyPathHelpersInternal::FInternalGetterResolver<T> Resolver(OutValue, OutProperty);
            return PropertyPathHelpersInternal::ResolvePropertyPath(InContainer, InPropertyPath, Resolver);
        }
    }
 
    template<typename T>
    bool GetPropertyValue(UObject* InContainer, const FString& InPropertyPath, T& OutValue)
    {
        FProperty* OutProperty;
        FCachedPropertyPath CachedPath(InPropertyPath);
        return GetPropertyValue<T>(InContainer, CachedPath, OutValue, OutProperty);
    }
 
    template<typename T>
    bool GetPropertyValue(UObject* InContainer, const FString& InPropertyPath, T& OutValue, FProperty*& OutProperty)
    {
        FCachedPropertyPath CachedPath(InPropertyPath);
        return GetPropertyValue<T>(InContainer, CachedPath, OutValue, OutProperty);
    }
 
    template<typename T>
    bool GetPropertyValue(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, T& OutValue)
    {
        FProperty* OutProperty;
        return GetPropertyValue<T>(InContainer, InPropertyPath, OutValue, OutProperty);
    }
 
    template<typename T>
    bool SetPropertyValueFast(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, const T& InValue)
    {
        check(InContainer);
        check(InContainer == InPropertyPath.GetCachedContainer());
        check(InPropertyPath.IsResolved());
 
        return PropertyPathHelpersInternal::SetValueFast<T>(InContainer, InPropertyPath, InValue);
    }
 
    template<typename T>
    bool SetPropertyValue(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, const T& InValue)
    {
        check(InContainer);
 
        if(InPropertyPath.IsFullyResolved())
        {
            return SetPropertyValueFast<T>(InContainer, InPropertyPath, InValue);
        }
        else
        {
            PropertyPathHelpersInternal::FInternalSetterResolver<T> Resolver(InValue);
            return PropertyPathHelpersInternal::ResolvePropertyPath(InContainer, InPropertyPath, Resolver);
        }
    }
 
    template<typename T>
    bool SetPropertyValue(UObject* InContainer, const FString& InPropertyPath, const T& InValue)
    {
        FCachedPropertyPath CachedPath(InPropertyPath);
        return SetPropertyValue(InContainer, CachedPath, InValue);
    }
 
    PROPERTYPATH_API bool SetPropertyValue(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, const UScriptStruct* InScriptStruct, const uint8* InValue);
 
    PROPERTYPATH_API bool SetPropertyValue(UObject* InContainer, const FString& InPropertyPath, const UScriptStruct* InScriptStruct, const uint8* InValue);
 
    PROPERTYPATH_API bool CopyPropertyValue(UObject* InContainer, const FCachedPropertyPath& InDestPropertyPath, const FCachedPropertyPath& InSrcPropertyPath);
 
    PROPERTYPATH_API bool CopyPropertyValueFast(UObject* InContainer, const FCachedPropertyPath& InDestPropertyPath, const FCachedPropertyPath& InSrcPropertyPath);
 
    PROPERTYPATH_API void FindFieldNameAndArrayIndex(int32 InCount, const TCHAR* InString, int32& OutCount, const TCHAR** OutPropertyName, int32& OutArrayIndex);
 
    PROPERTYPATH_API bool PerformArrayOperation(UObject* InContainer, const FString& InPropertyPath, TFunctionRef<bool(FScriptArrayHelper&,int32)> InOperation);
 
    PROPERTYPATH_API bool PerformArrayOperation(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, TFunctionRef<bool(FScriptArrayHelper&,int32)> InOperation);
}
 
namespace PropertyPathHelpersInternal
{
    struct FPropertyPathResolver
    {
        virtual ~FPropertyPathResolver() {}
 
        virtual bool Resolve(void* InContainer, const FCachedPropertyPath& InPropertyPath) = 0;
        virtual bool Resolve(UObject* InContainer, const FCachedPropertyPath& InPropertyPath) =  0;
    };
 
    struct FPropertyStructView
    {
        explicit FPropertyStructView(const UScriptStruct* InScriptStruct, const uint8* InMemory)
            : ScriptStruct(InScriptStruct)
            , Memory(InMemory)
        {
        }
 
        const UScriptStruct* ScriptStruct;
        const uint8* Memory;
    };
 
    template<typename DerivedType>
    struct TPropertyPathResolver : public FPropertyPathResolver
    {
        virtual bool Resolve(void* InContainer, const FCachedPropertyPath& InPropertyPath) override
        {
            return static_cast<DerivedType*>(this)->template Resolve_Impl<void>(InContainer, InPropertyPath);
        }
 
        virtual bool Resolve(UObject* InContainer, const FCachedPropertyPath& InPropertyPath) override
        {
            return static_cast<DerivedType*>(this)->template Resolve_Impl<UObject>(InContainer, InPropertyPath);
        }
    };
 
    PROPERTYPATH_API FProperty* GetFirstParamProperty(UFunction* InFunction);
 
    PROPERTYPATH_API void CallParentSetters(const FCachedPropertyPath& InPropertyPath);
 
    PROPERTYPATH_API void CallParentGetters(void* OutValue, const FCachedPropertyPath& InPropertyPath, const void* InPropertyAddress);
 
    template<typename T, typename ContainerType>
    struct FCallGetterFunctionHelper
    {
        static bool CallGetterFunction(ContainerType* InContainer, UFunction* InFunction, T& OutValue) 
        {
            // Cant call UFunctions on non-UObject containers
            return false;
        }
    };
 
    template<typename T>
    struct FCallGetterFunctionHelper<T, UObject>
    {
        static bool CallGetterFunction(UObject* InContainer, UFunction* InFunction, T& OutValue) 
        {
            // We only support calling functions that return a single value and take no parameters.
            if ( InFunction->NumParms == 1 )
            {
                // Find the pointer to the only param
                FProperty* ReturnProperty = nullptr;
                for (TFieldIterator<FProperty> It(InFunction); It; ++It)
                {
                    if (It->PropertyFlags & CPF_Parm)
                    {
                        ReturnProperty = *It;
                        break;
                    }
                }
 
                // Verify there's a return property.
                if ( ReturnProperty && ReturnProperty->PropertyFlags & (CPF_ReturnParm | CPF_OutParm) )
                {
                    // Verify that the cpp type matches a known property type.
                    if ( IsConcreteTypeCompatibleWithReflectedType<T>(ReturnProperty) )
                    {
                        // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                        if ( PropertySizesMatch<T>(ReturnProperty) && !InContainer->IsUnreachable() )
                        {
                            InContainer->ProcessEvent(InFunction, &OutValue);
                            return true;
                        }
                    }
                }
            }
 
            return false;
        }
    };
 
    template<typename T, typename ContainerType>
    struct FGetValueHelper
    {
        static bool GetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, T& OutValue, FProperty*& OutProperty)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            int32 ArrayIndex = LastSegment.GetArrayIndex();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
 
            // Verify that the cpp type matches a known property type.
            if ( IsConcreteTypeCompatibleWithReflectedType<T>(Property) )
            {
                ArrayIndex = ArrayIndex == INDEX_NONE ? 0 : ArrayIndex;
                if (PropertySizesMatch<T>(Property) && ArrayIndex < Property->ArrayDim)
                {
                    if (Property->HasGetter())
                    {
                        Property->CallGetter(InContainer, &OutValue);
                    }
                    else if (void* Address = Property->ContainerPtrToValuePtr<T>(InContainer, ArrayIndex))
                    {
                        InPropertyPath.ResolveLeaf(Address);
                        CallParentGetters(&OutValue, InPropertyPath, Address);
                    }
                    OutProperty = Property;
                    return true;
                }
            }
 
            return false;
        }
    };
 
    template<typename T, typename ContainerType, int32 N>
    struct FGetValueHelper<T[N], ContainerType>
    {
        static bool GetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, T(&OutValue)[N], FProperty*& OutProperty)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
 
            // Verify that the cpp type matches a known property type.
            if ( IsConcreteTypeCompatibleWithReflectedType<T>(Property) )
            {
                if ( PropertySizesMatch<T>(Property) && Property->ArrayDim == N )
                {
                    if(void* Address = Property->ContainerPtrToValuePtr<T>(InContainer))
                    {
                        InPropertyPath.ResolveLeaf(Address);
                        Property->CopyCompleteValue(&OutValue, Address);
                        OutProperty = Property;
                        return true;
                    }
                }
            }
 
            return true;
        }
    };
 
    template<typename ContainerType>
    struct FGetValueHelper<bool, ContainerType>
    {
        static bool GetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, bool& OutValue, FProperty*& OutProperty)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            int32 ArrayIndex = LastSegment.GetArrayIndex();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
 
            // Verify that the cpp type matches a known property type.
            if ( IsConcreteTypeCompatibleWithReflectedType<bool>(Property) )
            {
                ArrayIndex = ArrayIndex == INDEX_NONE ? 0 : ArrayIndex;
                if ( PropertySizesMatch<bool>(Property) && ArrayIndex < Property->ArrayDim )
                {
                    if(void* Address = Property->ContainerPtrToValuePtr<bool>(InContainer, ArrayIndex))
                    {
                        InPropertyPath.ResolveLeaf(Address);
                        FBoolProperty* BoolProperty = CastFieldChecked<FBoolProperty>(LastSegment.GetField().ToField());
                        OutValue = BoolProperty->GetPropertyValue(Address);
                        OutProperty = Property;
                        return true;
                    }
                }
            }
 
            return false;
        }
    };
 
    template<typename T, typename ContainerType>
    bool GetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, FProperty*& OutProperty, T& OutValue)
    {
        const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
        int32 ArrayIndex = LastSegment.GetArrayIndex();
        FFieldVariant Field = LastSegment.GetField();
 
        // We're on the final property in the path, it may be an array property, so check that first.
        if ( FArrayProperty* ArrayProp = Field.Get<FArrayProperty>() )
        {
            // if it's an array property, we need to see if we parsed an index as part of the segment
            // as a user may have baked the index directly into the property path.
            if(ArrayIndex != INDEX_NONE)
            {
                // Property is an array property, so make sure we have a valid index specified
                FScriptArrayHelper_InContainer ArrayHelper(ArrayProp, InContainer);
                if ( ArrayHelper.IsValidIndex(ArrayIndex) )
                {
                    // Verify that the cpp type matches a known property type.
                    if ( IsConcreteTypeCompatibleWithReflectedType<T>(ArrayProp->Inner) )
                    {
                        // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                        if ( PropertySizesMatch<T>(ArrayProp->Inner) )
                        {
                            if(void* Address = static_cast<void*>(ArrayHelper.GetRawPtr(ArrayIndex)))
                            {
                                InPropertyPath.ResolveLeaf(Address);
                                ArrayProp->Inner->CopySingleValue(&OutValue, Address);
                                OutProperty = ArrayProp->Inner;
                                return true;
                            }
                        }
                    }
                }
            }
            else
            {
                // No index, so assume we want the array property itself
                if ( IsConcreteTypeCompatibleWithReflectedType<T>(ArrayProp) )
                {
                    if ( PropertySizesMatch<T>(ArrayProp) )
                    {
                        if(void* Address = ArrayProp->ContainerPtrToValuePtr<T>(InContainer))
                        {
                            InPropertyPath.ResolveLeaf(Address);
                            ArrayProp->CopySingleValue(&OutValue, Address);
                            OutProperty = ArrayProp;
                            return true;
                        }
                    }
                }
            }
        }
        else if(UFunction* Function = Field.Get<UFunction>())
        {
            InPropertyPath.ResolveLeaf(Function);
            return FCallGetterFunctionHelper<T, ContainerType>::CallGetterFunction(InContainer, Function, OutValue);
        }
        else if(FProperty* Property = Field.Get<FProperty>())
        {
            return FGetValueHelper<T, ContainerType>::GetValue(InContainer, InPropertyPath, OutValue, OutProperty);
        }
 
        return false;
    }
 
    template<typename T>
    struct FInternalGetterResolver : public TPropertyPathResolver<FInternalGetterResolver<T>>
    {
        FInternalGetterResolver(T& InValue, FProperty*& InOutProperty)
            : Value(InValue)
            , Property(InOutProperty)
        {
        }
 
        template<typename ContainerType>
        bool Resolve_Impl(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath)
        {
            return GetValue<T>(InContainer, InPropertyPath, Property, Value);
        }
 
        T& Value;
        FProperty*& Property;
    };
 
    template<typename T, typename ContainerType>
    struct FCallSetterFunctionHelper
    {
        static bool CallSetterFunction(ContainerType* InContainer, UFunction* InFunction, const T& InValue)
        {
            // Cant call UFunctions on non-UObject containers
            return false;
        }
    };
 
    template<typename T>
    struct FCallSetterFunctionHelper<T, UObject>
    {
        static bool CallSetterFunction(UObject* InContainer, UFunction* InFunction, const T& InValue)
        {
            // We only support calling functions that take a single value and return no parameters
            if ( InFunction->NumParms == 1 && InFunction->GetReturnProperty() == nullptr )
            {
                // Verify there's a return property.
                if ( FProperty* ParamProperty = GetFirstParamProperty(InFunction) )
                {
                    if constexpr (std::is_same<FPropertyStructView, T>::value)
                    {
                        const FPropertyStructView& InStuctView = static_cast<const FPropertyStructView&>(InValue);
 
                        // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                        if (ParamProperty->GetElementSize() == InStuctView.ScriptStruct->GetStructureSize() && !InContainer->IsUnreachable())
                        {
                            InContainer->ProcessEvent(InFunction, const_cast<uint8*>(InStuctView.Memory));
                            return true;
                        }
                    }
                    // Verify that the cpp type matches a known property type.
                    else if ( IsConcreteTypeCompatibleWithReflectedType<T>(ParamProperty) )
                    {
                        // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                        if ( PropertySizesMatch<T>(ParamProperty) && !InContainer->IsUnreachable() )
                        {
                            InContainer->ProcessEvent(InFunction, const_cast<T*>(&InValue));
                            return true;
                        }
                    }
                }
            }
            else
            {
                //LOG ERROR
            }
 
            return false;
        }
    };
 
    template<typename T, typename ContainerType>
    struct FSetValueHelper
    {
        static bool SetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, const T& InValue)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            int32 ArrayIndex = LastSegment.GetArrayIndex();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
 
            if constexpr (std::is_same<FPropertyStructView, T>::value)
            {
                const FPropertyStructView& InStuctView = static_cast<const FPropertyStructView&>(InValue);
 
                // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                ArrayIndex = ArrayIndex == INDEX_NONE ? 0 : ArrayIndex;
                if ( Property->GetElementSize() == InStuctView.ScriptStruct->GetStructureSize() && ArrayIndex < Property->ArrayDim)
                {
                    if (Property->HasSetter())
                    {
                        Property->CallSetter(InContainer, InStuctView.Memory);
                    }
                    else if (void* Address = Property->ContainerPtrToValuePtr<void>(InContainer, ArrayIndex))
                    {
                        InPropertyPath.ResolveLeaf(Address);
                        Property->CopySingleValue(Address, InStuctView.Memory);
                        CallParentSetters(InPropertyPath);
                    }
                    return true;
                }
            }
            // Verify that the cpp type matches a known property type.
            else if ( IsConcreteTypeCompatibleWithReflectedType<T>(Property) )
            {
                // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                ArrayIndex = ArrayIndex == INDEX_NONE ? 0 : ArrayIndex;
                if ( PropertySizesMatch<T>(Property) && ArrayIndex < Property->ArrayDim )
                {
                    if (Property->HasSetter())
                    {
                        Property->CallSetter(InContainer, &InValue);
                    }
                    else if (void* Address = Property->ContainerPtrToValuePtr<T>(InContainer, ArrayIndex))
                    {
                        InPropertyPath.ResolveLeaf(Address);
                        Property->CopySingleValue(Address, &InValue);
                        CallParentSetters(InPropertyPath);
                    }
                    return true;
                }
            }
 
            return false;
        }
    };
 
    template<typename T, typename ContainerType, int32 N>
    struct FSetValueHelper<T[N], ContainerType>
    {
        static bool SetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, const T(&InValue)[N])
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
 
            // Verify that the cpp type matches a known property type.
            if ( IsConcreteTypeCompatibleWithReflectedType<T>(Property) )
            {
                // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                if ( PropertySizesMatch<T>(Property) && Property->ArrayDim == N )
                {
                    if(void* Address = Property->ContainerPtrToValuePtr<T>(InContainer))
                    {
                        InPropertyPath.ResolveLeaf(Address);
                        Property->CopyCompleteValue(Address, &InValue);
                        return true;
                    }
                }
            }
 
            return false;
        }
    };
 
    template<typename ContainerType>
    struct FSetValueHelper<bool, ContainerType>
    {
        static bool SetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, const bool& InValue)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            int32 ArrayIndex = LastSegment.GetArrayIndex();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
 
            // Verify that the cpp type matches a known property type.
            if ( IsConcreteTypeCompatibleWithReflectedType<bool>(Property) )
            {
                // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                ArrayIndex = ArrayIndex == INDEX_NONE ? 0 : ArrayIndex;
                if ( PropertySizesMatch<bool>(Property) && ArrayIndex < Property->ArrayDim )
                {
                    if(void* Address = Property->ContainerPtrToValuePtr<bool>(InContainer, ArrayIndex))
                    {
                        InPropertyPath.ResolveLeaf(Address);
 
                        if (Property->HasSetter())
                        {
                            // Setter should be specialized to handle masking
                            Property->CallSetter(InContainer, &InValue);
                        }
                        else
                        {
                            FBoolProperty* BoolProperty = CastFieldChecked<FBoolProperty>(Property);
                            BoolProperty->SetPropertyValue(InPropertyPath.GetCachedAddress(), InValue);
                            CallParentSetters(InPropertyPath);
                        }
                        return true;
                    }
                }
            }
 
            return false;
        }
    };
 
    template<typename T, typename ContainerType>
    bool SetValue(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, const T& InValue)
    {
        const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
        int32 ArrayIndex = LastSegment.GetArrayIndex();
        FFieldVariant Field = LastSegment.GetField();
 
        // We're on the final property in the path, it may be an array property, so check that first.
        if ( FArrayProperty* ArrayProp = Field.Get<FArrayProperty>() )
        {
            // if it's an array property, we need to see if we parsed an index as part of the segment
            // as a user may have baked the index directly into the property path.
            if(ArrayIndex != INDEX_NONE)
            {
                // Property is an array property, so make sure we have a valid index specified
                FScriptArrayHelper_InContainer ArrayHelper(ArrayProp, InContainer);
                if ( ArrayHelper.IsValidIndex(ArrayIndex) )
                {
                    if constexpr (std::is_same<FPropertyStructView, T>::value)
                    {
                        const FPropertyStructView& InStuctView = static_cast<const FPropertyStructView&>(InValue);
 
                        // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                        if (ArrayProp->Inner->GetElementSize() == InStuctView.ScriptStruct->GetStructureSize())
                        {
                            if (void* Address = static_cast<void*>(ArrayHelper.GetRawPtr(ArrayIndex)))
                            {
                                InPropertyPath.ResolveLeaf(Address);
                                ArrayProp->Inner->CopySingleValue(Address, InStuctView.Memory);
                                return true;
                            }
                        }
                    }
                    else
                    {
                        // Verify that the cpp type matches a known property type.
                        if (IsConcreteTypeCompatibleWithReflectedType<T>(ArrayProp->Inner))
                        {
                            // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                            if (PropertySizesMatch<T>(ArrayProp->Inner))
                            {
                                if (void* Address = static_cast<void*>(ArrayHelper.GetRawPtr(ArrayIndex)))
                                {
                                    InPropertyPath.ResolveLeaf(Address);
                                    ArrayProp->Inner->CopySingleValue(Address, &InValue);
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                // No index, so assume we want the array property itself
                // Verify that the cpp type matches a known property type.
                if constexpr (!std::is_same<FPropertyStructView, T>::value)
                {
                    if (IsConcreteTypeCompatibleWithReflectedType<T>(ArrayProp))
                    {
                        // Ensure that the element sizes are the same, prevents the user from doing something terribly wrong.
                        if (PropertySizesMatch<T>(ArrayProp))
                        {
                            if (void* Address = ArrayProp->ContainerPtrToValuePtr<T>(InContainer))
                            {
                                InPropertyPath.ResolveLeaf(Address);
                                ArrayProp->CopySingleValue(Address, &InValue);
                                return true;
                            }
                        }
                    }
                }
            }
        }
        else if(UFunction* Function = Field.Get<UFunction>())
        {
            InPropertyPath.ResolveLeaf(Function);
            return FCallSetterFunctionHelper<T, ContainerType>::CallSetterFunction(InContainer, Function, InValue);
        }
        else if(FProperty* Property = Field.Get<FProperty>())
        {
            return FSetValueHelper<T, ContainerType>::SetValue(InContainer, InPropertyPath, InValue);
        }
 
        return false;
    }
 
    template<typename T>
    struct FInternalSetterResolver : public TPropertyPathResolver<FInternalSetterResolver<T>>
    {
        FInternalSetterResolver(const T& InValueToSet)
            : Value(InValueToSet)
        {
        }
 
        template<typename ContainerType>
        bool Resolve_Impl(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath)
        {
            return SetValue<T>(InContainer, InPropertyPath, Value);
        }
 
        const T& Value;
    };
 
    PROPERTYPATH_API bool ResolvePropertyPath(UObject* InContainer, const FCachedPropertyPath& InPropertyPath, FPropertyPathResolver& InResolver);
 
    PROPERTYPATH_API bool ResolvePropertyPath(void* InContainer, UStruct* InStruct, const FCachedPropertyPath& InPropertyPath, FPropertyPathResolver& InResolver);
 
    PROPERTYPATH_API bool ResolvePropertyPath(UObject* InContainer, const FString& InPropertyPath, FPropertyPathResolver& InResolver);
 
    PROPERTYPATH_API bool ResolvePropertyPath(void* InContainer, UStruct* InStruct, const FString& InPropertyPath, FPropertyPathResolver& InResolver);
 
    template<typename T>
    struct FGetValueFastHelper
    {
        static bool GetValue(const FCachedPropertyPath& InPropertyPath, T& OutValue, FProperty*& OutProperty)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            OutProperty = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
            FArrayProperty* ArrayProp = CastField<FArrayProperty>(OutProperty);
            if ( ArrayProp && LastSegment.GetArrayIndex() != INDEX_NONE )
            {
                if (IsConcreteTypeCompatibleWithReflectedType<T>(ArrayProp->Inner))
                {
                    ArrayProp->Inner->CopySingleValue(&OutValue, InPropertyPath.GetCachedAddress());
                    return true;
                }
            }
            else if (IsConcreteTypeCompatibleWithReflectedType<T>(OutProperty))
            {
                if (OutProperty->HasGetter())
                {
                    OutProperty->CallGetter(InPropertyPath.GetCachedContainer(), &OutValue);
                }
                else
                {
                    CallParentGetters(&OutValue, InPropertyPath, InPropertyPath.GetCachedAddress());
                }   
                return true;
            }
            return false;
        }
    };
 
    template<typename T, int32 N>
    struct FGetValueFastHelper<T[N]>
    {
        static bool GetValue(const FCachedPropertyPath& InPropertyPath, T(&OutValue)[N], FProperty*& OutProperty)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            OutProperty = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
            if (IsConcreteTypeCompatibleWithReflectedType<T>(OutProperty))
            {
                OutProperty->CopyCompleteValue(&OutValue, InPropertyPath.GetCachedAddress());
                return true;
            }
            return false;
        }
    };
 
    template<typename T, typename ContainerType>
    bool GetValueFast(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, T& OutValue, FProperty*& OutProperty)
    {
        if(InPropertyPath.GetCachedFunction())
        {
            return FCallGetterFunctionHelper<T, ContainerType>::CallGetterFunction(InContainer, InPropertyPath.GetCachedFunction(), OutValue);
        }
        else if(InPropertyPath.GetCachedAddress())
        {
            return FGetValueFastHelper<T>::GetValue(InPropertyPath, OutValue, OutProperty);
        }
 
        return false;
    }
 
    template<typename T>
    struct FSetValueFastHelper
    {
        static bool SetValue(const FCachedPropertyPath& InPropertyPath, const T& InValue)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
            FArrayProperty* ArrayProp = CastField<FArrayProperty>(Property);
 
            const void* Value = nullptr;
            if constexpr (std::is_same<FPropertyStructView, T>::value)
            {
                const FPropertyStructView& InStuctView = static_cast<const FPropertyStructView&>(InValue);
                Value = static_cast<const void*>(InStuctView.Memory);
            }
            else
            {
                Value = &InValue;
            }
 
            auto IsPropertyCompatible = [](FProperty* InProperty)
            {
                if constexpr (!std::is_same<FPropertyStructView, T>::value)
                {
                    if (!IsConcreteTypeCompatibleWithReflectedType<T>(InProperty))
                    {
                        return false;
                    }
                }
 
                return true;
            };
 
            if ( ArrayProp && LastSegment.GetArrayIndex() != INDEX_NONE )
            {
                if (!IsPropertyCompatible(ArrayProp->Inner))
                {
                    return false;
                }
 
                ArrayProp->Inner->CopySingleValue(InPropertyPath.GetCachedAddress(), Value);
                return true;
            }
            else 
            {
                if (!IsPropertyCompatible(Property))
                {
                    return false;
                }
 
                if (Property->HasSetter())
                {
                    Property->CallSetter(InPropertyPath.GetCachedContainer(), Value);
                }
                else
                {
                    Property->CopySingleValue(InPropertyPath.GetCachedAddress(), Value);
                    CallParentSetters(InPropertyPath);
                }
                return true;
            }
        }
    };
 
    template<typename T, int32 N>
    struct FSetValueFastHelper<T[N]>
    {
        static bool SetValue(const FCachedPropertyPath& InPropertyPath, const T(&InValue)[N])
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
            if (IsConcreteTypeCompatibleWithReflectedType<T>(Property))
            {
                Property->CopyCompleteValue(InPropertyPath.GetCachedAddress(), &InValue);
                return true;
            }
            return false;
        }
    };
 
    template<>
    struct FSetValueFastHelper<bool>
    {
        static bool SetValue(const FCachedPropertyPath& InPropertyPath, const bool& InValue)
        {
            const FPropertyPathSegment& LastSegment = InPropertyPath.GetLastSegment();
            FProperty* Property = CastFieldChecked<FProperty>(LastSegment.GetField().ToField());
            FArrayProperty* ArrayProp = CastField<FArrayProperty>(Property);
            if ( ArrayProp && LastSegment.GetArrayIndex() != INDEX_NONE )
            {
                if (IsConcreteTypeCompatibleWithReflectedType<bool>(ArrayProp->Inner))
                {
                    ArrayProp->Inner->CopySingleValue(InPropertyPath.GetCachedAddress(), &InValue);
                    return true;
                }
            }
            else if (IsConcreteTypeCompatibleWithReflectedType<bool>(Property))
            {
                if (Property->HasSetter())
                {
                    // Setter should be specialized to handle masking
                    Property->CallSetter(InPropertyPath.GetCachedContainer(), &InValue);
                }
                else
                {
                    FBoolProperty* BoolProperty = CastFieldChecked<FBoolProperty>(Property);
                    BoolProperty->SetPropertyValue(InPropertyPath.GetCachedAddress(), InValue);
                    CallParentSetters(InPropertyPath);
                }
                return true;
            }
            return false;
        }
    };
 
    template<typename T, typename ContainerType>
    bool SetValueFast(ContainerType* InContainer, const FCachedPropertyPath& InPropertyPath, const T& InValue)
    {
        if(InPropertyPath.GetCachedFunction())
        {
            return FCallSetterFunctionHelper<T, ContainerType>::CallSetterFunction(InContainer, InPropertyPath.GetCachedFunction(), InValue);
        }
        else if(InPropertyPath.GetCachedAddress())
        {
            return FSetValueFastHelper<T>::SetValue(InPropertyPath, InValue);
        }
 
        return false;
    }
}