PropertyBag.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Misc/TVariantMeta.h"
#include "StructUtils/StructView.h"
#include "Templates/ValueOrError.h"
#include "Containers/StaticArray.h"
#include "UObject/ScriptMacros.h"
#include "UObject/ObjectMacros.h"
 
#include "PropertyBag.generated.h"
 
#define UE_API COREUOBJECT_API
 
UENUM(BlueprintType)
enum class EPropertyBagPropertyType : uint8
{
    None UMETA(Hidden),
    Bool,
    Byte,
    Int32,
    Int64,
    Float,
    Double,
    Name,
    String,
    Text,
    Enum UMETA(Hidden),
    Struct UMETA(Hidden),
    Object UMETA(Hidden),
    SoftObject UMETA(Hidden),
    Class UMETA(Hidden),
    SoftClass UMETA(Hidden),
    UInt32, // Type not fully supported at UI, will work with restrictions to type editing
    UInt64, // Type not fully supported at UI, will work with restrictions to type editing
 
    Count UMETA(Hidden)
};
 
UENUM(BlueprintType)
enum class EPropertyBagContainerType : uint8
{
    None,
    Array,
    Set,
 
    Count UMETA(Hidden)
};
 
namespace FPropertyBagCustomVersion
{
    COREUOBJECT_API extern const FGuid GUID;
}
 
USTRUCT()
struct FPropertyBagContainerTypes
{
    GENERATED_BODY()
 
    FPropertyBagContainerTypes() = default;
 
    explicit FPropertyBagContainerTypes(EPropertyBagContainerType ContainerType)
    {
        if (ContainerType != EPropertyBagContainerType::None)
        {
            Add(ContainerType);
        }
    }
 
    FPropertyBagContainerTypes(const std::initializer_list<EPropertyBagContainerType>& InTypes)
    {
        for (const EPropertyBagContainerType ContainerType : InTypes)
        {
            if (ContainerType != EPropertyBagContainerType::None)
            {
                Add(ContainerType);
            }
        }
    }
 
    bool Add(const EPropertyBagContainerType PropertyBagContainerType)
    {
        if (ensure(NumContainers < MaxNestedTypes))
        {
            if (PropertyBagContainerType != EPropertyBagContainerType::None)
            {
                Types[NumContainers] = PropertyBagContainerType;
                NumContainers++;
 
                return true;
            }
        }
 
        return false;
    }
 
    void Reset()
    {
        for (EPropertyBagContainerType& Type : Types)
        {
            Type = EPropertyBagContainerType::None;
        }
        NumContainers = 0;
    }
 
    bool IsEmpty() const
    {
        return NumContainers == 0;
    }
 
    uint32 Num() const
    {
        return NumContainers;
    }
 
    bool CanAdd() const
    {
        return NumContainers < MaxNestedTypes;
    }
 
    EPropertyBagContainerType GetFirstContainerType() const
    {
        return NumContainers > 0 ? Types[0] : EPropertyBagContainerType::None;
    }
 
    EPropertyBagContainerType operator[] (int32 Index) const
    {
        return ensure(Index < NumContainers) ? Types[Index] : EPropertyBagContainerType::None;
    }
 
    UE_API EPropertyBagContainerType PopHead();
 
    UE_API void Serialize(FArchive& Ar);
 
    friend FArchive& operator<<(FArchive& Ar, FPropertyBagContainerTypes& ContainerTypesData)
    {
        ContainerTypesData.Serialize(Ar);
        return Ar;
    }
 
    UE_API bool operator == (const FPropertyBagContainerTypes& Other) const;
 
    UE_FORCEINLINE_HINT bool operator !=(const FPropertyBagContainerTypes& Other) const
    {
        return !(Other == *this);
    }
 
    friend UE_FORCEINLINE_HINT uint32 GetTypeHash(const FPropertyBagContainerTypes& PropertyBagContainerTypes)
    {
        return GetArrayHash(PropertyBagContainerTypes.Types.GetData(), PropertyBagContainerTypes.NumContainers);
    }
 
    EPropertyBagContainerType* begin() { return Types.GetData(); }
    const EPropertyBagContainerType* begin() const { return Types.GetData(); }
    EPropertyBagContainerType* end()  { return Types.GetData() + NumContainers; }
    const EPropertyBagContainerType* end() const { return Types.GetData() + NumContainers; }
 
protected:
    static constexpr uint8 MaxNestedTypes = 2;
 
    TStaticArray<EPropertyBagContainerType, MaxNestedTypes> Types = TStaticArray<EPropertyBagContainerType, MaxNestedTypes>(InPlace, EPropertyBagContainerType::None);
    uint8 NumContainers = 0;
};
 
UENUM()
enum class EPropertyBagResult : uint8
{
    Success,            // Operation succeeded.
    TypeMismatch,       // Tried to access mismatching type (e.g. setting a struct to bool)
    OutOfBounds,        // Tried to access an array property out of bounds.
    PropertyNotFound,   // Could not find property of specified name.
    DuplicatedValue,    // Tried to set an already existing Set Entry
};
 
UENUM()
enum class EPropertyBagAlterationResult : uint8
{
    Success,                             // Operation succeeded.
    NoOperation = Success UMETA(Hidden), // No operation was necessary to warrant a successful operation. Semantic alias.
    InternalError,                       // The operation could not be completed, due to an internal property bag error.
    PropertyNameEmpty,                   // The property name is empty.
    PropertyNameInvalidCharacters,       // The property name contains illegal characters. Consider using FInstancedPropertyBag::SanitizePropertyName.
    SourcePropertyNotFound,              // The source property or property name was not found.
    TargetPropertyNotFound,              // The target property or property name was not found.
    TargetPropertyAlreadyExists          // The target property or property name already exists.
};
 
USTRUCT()
struct FPropertyBagPropertyDescMetaData
{
    GENERATED_BODY()
    
    FPropertyBagPropertyDescMetaData() = default;
    FPropertyBagPropertyDescMetaData(const FName InKey, const FString& InValue)
        : Key(InKey)
        , Value(InValue)
    {
    }
    
    UPROPERTY()
    FName Key;
 
    UPROPERTY()
    FString Value;
 
    UE_API void Serialize(FArchive& Ar);
 
    bool operator==(const FPropertyBagPropertyDescMetaData& Other) const
    {
        return Key == Other.Key && Value == Other.Value;
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, FPropertyBagPropertyDescMetaData& PropertyDescMetaData)
    {
        PropertyDescMetaData.Serialize(Ar);
        return Ar;
    }
 
    friend UE_FORCEINLINE_HINT uint32 GetTypeHash(const FPropertyBagPropertyDescMetaData& PropertyDescMetaData)
    {
        return HashCombine(GetTypeHash(PropertyDescMetaData.Key), GetTypeHash(PropertyDescMetaData.Value));
    }
 
    friend inline uint32 GetTypeHash(const TArrayView<const FPropertyBagPropertyDescMetaData>& MetaData)
    {
        uint32 Hash = GetTypeHash(MetaData.Num());
        for (const FPropertyBagPropertyDescMetaData& PropertyDescMetaData : MetaData)
        {
            Hash = HashCombine(Hash, GetTypeHash(PropertyDescMetaData));
        }
        return Hash;
    }
 
    friend UE_FORCEINLINE_HINT uint32 GetTypeHash(const TArray<FPropertyBagPropertyDescMetaData>& MetaData)
    {
        return GetTypeHash(TArrayView<const FPropertyBagPropertyDescMetaData>(MetaData.GetData(), MetaData.Num()));
    }
};
 
USTRUCT()
struct FPropertyBagPropertyDesc
{
    GENERATED_BODY()
 
    static_assert(std::is_same_v<std::underlying_type_t<EPropertyFlags>, uint64>, "FPropertyBagPropertyDesc::PropertyFlag does not match EPropertyFlags type");
 
    FPropertyBagPropertyDesc() = default;
    UE_API FPropertyBagPropertyDesc(const FName InName, const FProperty* InSourceProperty);
    FPropertyBagPropertyDesc(const FName InName, const EPropertyBagPropertyType InValueType, const UObject* InValueTypeObject = nullptr)
        : ValueTypeObject(InValueTypeObject)
        , Name(InName)
        , ValueType(InValueType)
    {
    }
    FPropertyBagPropertyDesc(const FName InName, const EPropertyBagContainerType InContainerType, const EPropertyBagPropertyType InValueType, const UObject* InValueTypeObject = nullptr, EPropertyFlags InPropertyFlags = CPF_Edit)
        : ValueTypeObject(InValueTypeObject)
        , Name(InName)
        , ValueType(InValueType)
        , ContainerTypes(InContainerType)
        , PropertyFlags((uint64)InPropertyFlags)
    {
    }
 
    FPropertyBagPropertyDesc(const FName InName, const FPropertyBagContainerTypes& InNestedContainers, const EPropertyBagPropertyType InValueType, UObject* InValueTypeObject = nullptr, EPropertyFlags InPropertyFlags = CPF_Edit)
        : ValueTypeObject(InValueTypeObject)
        , Name(InName)
        , ValueType(InValueType)
        , ContainerTypes(InNestedContainers)
        , PropertyFlags((uint64)InPropertyFlags)
    {
    }
 
    UE_API bool CompatibleType(const FPropertyBagPropertyDesc& Other) const;
 
    UE_API bool IsNumericType() const;
 
    UE_API bool IsUnsignedNumericType() const;
    
    UE_API bool IsNumericFloatType() const;
 
    UE_API bool IsObjectType() const;
 
    UE_API bool IsClassType() const;
 
    int32 GetCachedIndex() const { return CachedIndex; }
 
    UE_API bool operator==(const FPropertyBagPropertyDesc& OtherDesc) const;
 
    UE_API friend FArchive& operator<<(FArchive& Ar, FPropertyBagPropertyDesc& Desc);
 
#if WITH_EDITOR
    UE_API bool HasMetaData(FName SpecifierName) const;
 
    UE_API void SetMetaData(FName SpecifierName, const FString& InValue);
 
    UE_API FString GetMetaData(FName SpecifierName) const;
 
    UE_API void RemoveMetadata(FName SpecifierName);
#endif // WITH_EDITOR
 
    UPROPERTY(EditAnywhere, Category="Default")
    TObjectPtr<const UObject> ValueTypeObject = nullptr;
 
    UPROPERTY(EditAnywhere, Category="Default")
    FGuid ID;
 
    UPROPERTY(EditAnywhere, Category="Default")
    FName Name;
 
    UPROPERTY(EditAnywhere, Category="Default")
    EPropertyBagPropertyType ValueType = EPropertyBagPropertyType::None;
 
    UPROPERTY(EditAnywhere, Category="Default")
    FPropertyBagContainerTypes ContainerTypes;
 
    UPROPERTY(EditAnywhere, Category = "Default")
    uint64 PropertyFlags = (uint64)CPF_Edit;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category="Default")
    TArray<FPropertyBagPropertyDescMetaData> MetaData;
 
    UPROPERTY(EditAnywhere, Category = "Default")
    TObjectPtr<class UClass> MetaClass;
#endif
 
    const FProperty* CachedProperty = nullptr;
 
private:
    friend class UPropertyBag;
 
    int32 CachedIndex = INDEX_NONE;
};
 
class UPropertyBag;
class FPropertyBagArrayRef;
class FPropertyBagSetRef;
 
USTRUCT()
struct FInstancedPropertyBag
{
    GENERATED_BODY()
 
    FInstancedPropertyBag() = default;
    FInstancedPropertyBag(const FInstancedPropertyBag& Other) = default;
    FInstancedPropertyBag(FInstancedPropertyBag&& Other) = default;
 
    FInstancedPropertyBag& operator=(const FInstancedPropertyBag& InOther) = default;
    FInstancedPropertyBag& operator=(FInstancedPropertyBag&& InOther) = default;
 
    bool IsValid() const
    {
        return Value.IsValid();
    }
    
    void Reset()
    {
        Value.Reset();
    }
 
    UE_API void InitializeFromBagStruct(const UPropertyBag* NewBagStruct);
    
    UE_API void CopyMatchingValuesByID(const FInstancedPropertyBag& Other, TOptional<TConstArrayView<FGuid>> OptionalPropertyIdsSubset = {});
 
    UE_API void CopyMatchingValuesByName(const FInstancedPropertyBag& Other, TOptional<TConstArrayView<FName>> OptionalPropertyNamesSubset = {});
 
    UE_API int32 GetNumPropertiesInBag() const;
 
    UE_API EPropertyBagAlterationResult AddProperties(const TConstArrayView<FPropertyBagPropertyDesc> Descs, bool bOverwrite = true);
    
    UE_API EPropertyBagAlterationResult AddProperty(const FName InName, const EPropertyBagPropertyType InValueType, const UObject* InValueTypeObject = nullptr, bool bOverwrite = true);
 
    UE_API EPropertyBagAlterationResult AddContainerProperty(const FName InName, const EPropertyBagContainerType InContainerType, const EPropertyBagPropertyType InValueType, const UObject* InValueTypeObject = nullptr, bool bOverwrite = true);
 
    UE_API EPropertyBagAlterationResult AddContainerProperty(const FName InName, const FPropertyBagContainerTypes InContainerTypes, const EPropertyBagPropertyType InValueType, UObject* InValueTypeObject, bool bOverwrite = true);
 
    UE_API EPropertyBagAlterationResult AddProperty(const FName InName, const FProperty* InSourceProperty, bool bOverwrite = true);
 
    UE_API EPropertyBagAlterationResult DuplicateProperty(FName InName, FName* InOutNewName = nullptr);
 
    UE_API EPropertyBagResult ReplaceAllPropertiesAndValues(const TConstArrayView<FPropertyBagPropertyDesc> InDescs, const TConstArrayView<TConstArrayView<uint8>> InValues);
 
    UE_API EPropertyBagAlterationResult RemovePropertiesByName(const TConstArrayView<FName> PropertiesToRemove);
    
    UE_API EPropertyBagAlterationResult RemovePropertyByName(const FName PropertyToRemove);
 
    UE_API EPropertyBagAlterationResult RenameProperty(FName PropertyToRename, FName NewName);
 
    UE_API EPropertyBagAlterationResult ReorderProperty(FName SourcePropertyName, FName TargetPropertyName, bool bInsertBefore = true);
 
    UE_API EPropertyBagAlterationResult ReorderProperty(int32 SourcePropertyIndex, int32 TargetPropertyIndex, bool bInsertBefore = true);
 
    UE_API void MigrateToNewBagStruct(const UPropertyBag* NewBagStruct);
 
    UE_API void MigrateToNewBagInstance(const FInstancedPropertyBag& InNewBagInstance);
 
    UE_API void MigrateToNewBagInstanceWithOverrides(const FInstancedPropertyBag& InNewBagInstance, TConstArrayView<FGuid> OverriddenPropertyIDs);
 
    UE_API const UPropertyBag* GetPropertyBagStruct() const;
    
    UE_API const FPropertyBagPropertyDesc* FindPropertyDescByID(const FGuid ID) const;
    
    UE_API const FPropertyBagPropertyDesc* FindPropertyDescByName(const FName Name) const;
 
    UE_API bool OwnsPropertyDesc(const FPropertyBagPropertyDesc& Desc) const;
 
    UE_API bool HasSameLayout(const FInstancedPropertyBag& Other) const;
 
    FConstStructView GetValue() const { return Value; };
 
    FStructView GetMutableValue() { return Value; };
 
    UE_API FInstancedStruct Detach();
 
    UE_API TValueOrError<bool, EPropertyBagResult> GetValueBool(const FName Name) const;
    UE_API TValueOrError<uint8, EPropertyBagResult> GetValueByte(const FName Name) const;
    UE_API TValueOrError<int32, EPropertyBagResult> GetValueInt32(const FName Name) const;
    UE_API TValueOrError<uint32, EPropertyBagResult> GetValueUInt32(const FName Name) const;
    UE_API TValueOrError<int64, EPropertyBagResult> GetValueInt64(const FName Name) const;
    UE_API TValueOrError<uint64, EPropertyBagResult> GetValueUInt64(const FName Name) const;
    UE_API TValueOrError<float, EPropertyBagResult> GetValueFloat(const FName Name) const;
    UE_API TValueOrError<double, EPropertyBagResult> GetValueDouble(const FName Name) const;
    UE_API TValueOrError<FName, EPropertyBagResult> GetValueName(const FName Name) const;
    UE_API TValueOrError<FString, EPropertyBagResult> GetValueString(const FName Name) const;
    UE_API TValueOrError<FText, EPropertyBagResult> GetValueText(const FName Name) const;
    UE_API TValueOrError<uint8, EPropertyBagResult> GetValueEnum(const FName Name, const UEnum* RequestedEnum) const;
    UE_API TValueOrError<FStructView, EPropertyBagResult> GetValueStruct(const FName Name, const UScriptStruct* RequestedStruct = nullptr) const;
    UE_API TValueOrError<UObject*, EPropertyBagResult> GetValueObject(const FName Name, const UClass* RequestedClass = nullptr) const;
    UE_API TValueOrError<UClass*, EPropertyBagResult> GetValueClass(const FName Name) const;
    UE_API TValueOrError<FSoftObjectPath, EPropertyBagResult> GetValueSoftPath(const FName Name) const;
 
    UE_API TValueOrError<FString, EPropertyBagResult> GetValueSerializedString(const FName Name) const;
 
    template <typename T>
    TValueOrError<T, EPropertyBagResult> GetValueEnum(const FName Name) const
    {
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        
        TValueOrError<uint8, EPropertyBagResult> Result = GetValueEnum(Name, StaticEnum<T>());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        return MakeValue(static_cast<T>(Result.GetValue()));
    }
    
    template <typename T>
    TValueOrError<T*, EPropertyBagResult> GetValueStruct(const FName Name) const
    {
        TValueOrError<FStructView, EPropertyBagResult> Result = GetValueStruct(Name, TBaseStructure<T>::Get());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        if (T* ValuePtr = Result.GetValue().GetPtr<T>())
        {
            return MakeValue(ValuePtr);
        }
        return MakeError(EPropertyBagResult::TypeMismatch);
    }
    
    template <typename T>
    TValueOrError<T*, EPropertyBagResult> GetValueObject(const FName Name) const
    {
        static_assert(TIsDerivedFrom<T, UObject>::Value, "Should only call this with object types");
        
        TValueOrError<UObject*, EPropertyBagResult> Result = GetValueObject(Name, T::StaticClass());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        if (Result.GetValue() == nullptr)
        {
            return MakeValue(nullptr);
        }
        if (T* Object = Cast<T>(Result.GetValue()))
        {
            return MakeValue(Object);
        }
        return MakeError(EPropertyBagResult::TypeMismatch);
    }
 
    UE_API TValueOrError<bool, EPropertyBagResult> GetValueBool(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<uint8, EPropertyBagResult> GetValueByte(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<int32, EPropertyBagResult> GetValueInt32(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<uint32, EPropertyBagResult> GetValueUInt32(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<int64, EPropertyBagResult> GetValueInt64(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<uint64, EPropertyBagResult> GetValueUInt64(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<float, EPropertyBagResult> GetValueFloat(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<double, EPropertyBagResult> GetValueDouble(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<FName, EPropertyBagResult> GetValueName(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<FString, EPropertyBagResult> GetValueString(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<FText, EPropertyBagResult> GetValueText(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<uint8, EPropertyBagResult> GetValueEnum(const FPropertyBagPropertyDesc& Desc, const UEnum* RequestedEnum) const;
    UE_API TValueOrError<FStructView, EPropertyBagResult> GetValueStruct(const FPropertyBagPropertyDesc& Desc, const UScriptStruct* RequestedStruct = nullptr) const;
    UE_API TValueOrError<UObject*, EPropertyBagResult> GetValueObject(const FPropertyBagPropertyDesc& Desc, const UClass* RequestedClass = nullptr) const;
    UE_API TValueOrError<UClass*, EPropertyBagResult> GetValueClass(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<FSoftObjectPath, EPropertyBagResult> GetValueSoftPath(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<FPropertyBagArrayRef, EPropertyBagResult> GetMutableArrayRef(const FPropertyBagPropertyDesc& Desc);
    UE_API TValueOrError<const FPropertyBagArrayRef, EPropertyBagResult> GetArrayRef(const FPropertyBagPropertyDesc& Desc) const;
    UE_API TValueOrError<FPropertyBagSetRef, EPropertyBagResult> GetMutableSetRef(const FPropertyBagPropertyDesc& Desc);
    UE_API TValueOrError<const FPropertyBagSetRef, EPropertyBagResult> GetSetRef(const FPropertyBagPropertyDesc& Desc) const;
 
    template <typename T>
    TValueOrError<T, EPropertyBagResult> GetValueEnum(const FPropertyBagPropertyDesc& Desc) const
    {
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
 
        TValueOrError<uint8, EPropertyBagResult> Result = GetValueEnum(Desc, StaticEnum<T>());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        return MakeValue(static_cast<T>(Result.GetValue()));
    }
 
    template <typename T>
    TValueOrError<T*, EPropertyBagResult> GetValueStruct(const FPropertyBagPropertyDesc& Desc) const
    {
        TValueOrError<FStructView, EPropertyBagResult> Result = GetValueStruct(Desc, TBaseStructure<T>::Get());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        if (T* ValuePtr = Result.GetValue().GetPtr<T>())
        {
            return MakeValue(ValuePtr);
        }
        return MakeError(EPropertyBagResult::TypeMismatch);
    }
 
    template <typename T>
    TValueOrError<T*, EPropertyBagResult> GetValueObject(const FPropertyBagPropertyDesc& Desc) const
    {
        static_assert(TIsDerivedFrom<T, UObject>::Value, "Should only call this with object types");
 
        TValueOrError<UObject*, EPropertyBagResult> Result = GetValueObject(Desc, T::StaticClass());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        if (Result.GetValue() == nullptr)
        {
            return MakeValue(nullptr);
        }
        if (T* Object = Cast<T>(Result.GetValue()))
        {
            return MakeValue(Object);
        }
        return MakeError(EPropertyBagResult::TypeMismatch);
    }
 
    UE_API EPropertyBagResult SetValueBool(const FName Name, const bool bInValue);
    UE_API EPropertyBagResult SetValueByte(const FName Name, const uint8 InValue);
    UE_API EPropertyBagResult SetValueInt32(const FName Name, const int32 InValue);
    UE_API EPropertyBagResult SetValueUInt32(const FName Name, const uint32 InValue);
    UE_API EPropertyBagResult SetValueInt64(const FName Name, const int64 InValue);
    UE_API EPropertyBagResult SetValueUInt64(const FName Name, const uint64 InValue);
    UE_API EPropertyBagResult SetValueFloat(const FName Name, const float InValue);
    UE_API EPropertyBagResult SetValueDouble(const FName Name, const double InValue);
    UE_API EPropertyBagResult SetValueName(const FName Name, const FName InValue);
    UE_API EPropertyBagResult SetValueString(const FName Name, const FString& InValue);
    UE_API EPropertyBagResult SetValueText(const FName Name, const FText& InValue);
    UE_API EPropertyBagResult SetValueEnum(const FName Name, const uint8 InValue, const UEnum* Enum);
    UE_API EPropertyBagResult SetValueStruct(const FName Name, FConstStructView InValue);
    UE_API EPropertyBagResult SetValueObject(const FName Name, UObject* InValue);
    UE_API EPropertyBagResult SetValueClass(const FName Name, UClass* InValue);
    UE_API EPropertyBagResult SetValueSoftPath(const FName Name, const FSoftObjectPath& InValue);
    UE_API EPropertyBagResult SetValueSoftPath(const FName Name, const UObject* InValue);
 
    UE_API EPropertyBagResult SetValueSerializedString(const FName Name, const FString& InValue);
 
    template <typename T>
    EPropertyBagResult SetValueEnum(const FName Name, const T InValue)
    {
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        return SetValueEnum(Name, static_cast<uint8>(InValue), StaticEnum<T>());
    }
 
    template <typename T>
    EPropertyBagResult SetValueStruct(const FName Name, const T& InValue)
    {
        return SetValueStruct(Name, FConstStructView::Make(InValue));
    }
 
    template <typename T>
    EPropertyBagResult SetValueObject(const FName Name, T* InValue)
    {
        static_assert(TIsDerivedFrom<T, UObject>::Value, "Should only call this with object types");
        return SetValueObject(Name, (UObject*)InValue);
    }
 
    UE_API EPropertyBagResult SetValue(const FName Name, const FProperty* InSourceProperty, const void* InSourceContainerAddress);
 
    UE_API EPropertyBagResult SetValueBool(const FPropertyBagPropertyDesc& Desc, const bool bInValue);
    UE_API EPropertyBagResult SetValueByte(const FPropertyBagPropertyDesc& Desc, const uint8 InValue);
    UE_API EPropertyBagResult SetValueInt32(const FPropertyBagPropertyDesc& Desc, const int32 InValue);
    UE_API EPropertyBagResult SetValueUInt32(const FPropertyBagPropertyDesc& Desc, const uint32 InValue);
    UE_API EPropertyBagResult SetValueInt64(const FPropertyBagPropertyDesc& Desc, const int64 InValue);
    UE_API EPropertyBagResult SetValueUInt64(const FPropertyBagPropertyDesc& Desc, const uint64 InValue);
    UE_API EPropertyBagResult SetValueFloat(const FPropertyBagPropertyDesc& Desc, const float InValue);
    UE_API EPropertyBagResult SetValueDouble(const FPropertyBagPropertyDesc& Desc, const double InValue);
    UE_API EPropertyBagResult SetValueName(const FPropertyBagPropertyDesc& Desc, const FName InValue);
    UE_API EPropertyBagResult SetValueString(const FPropertyBagPropertyDesc& Desc, const FString& InValue);
    UE_API EPropertyBagResult SetValueText(const FPropertyBagPropertyDesc& Desc, const FText& InValue);
    UE_API EPropertyBagResult SetValueEnum(const FPropertyBagPropertyDesc& Desc, const uint8 InValue, const UEnum* Enum);
    UE_API EPropertyBagResult SetValueStruct(const FPropertyBagPropertyDesc& Desc, FConstStructView InValue);
    UE_API EPropertyBagResult SetValueObject(const FPropertyBagPropertyDesc& Desc, UObject* InValue);
    UE_API EPropertyBagResult SetValueClass(const FPropertyBagPropertyDesc& Desc, UClass* InValue);
    UE_API EPropertyBagResult SetValueSoftPath(const FPropertyBagPropertyDesc& Desc, const FSoftObjectPath& InValue);
    UE_API EPropertyBagResult SetValueSoftPath(const FPropertyBagPropertyDesc& Desc, const UObject* InValue);
 
    template <typename T>
    EPropertyBagResult SetValueEnum(const FPropertyBagPropertyDesc& Desc, const T InValue)
    {
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        return SetValueEnum(Desc, static_cast<uint8>(InValue), StaticEnum<T>());
    }
 
    template <typename T>
    EPropertyBagResult SetValueStruct(const FPropertyBagPropertyDesc& Desc, const T& InValue)
    {
        return SetValueStruct(Desc, FConstStructView::Make(InValue));
    }
 
    template <typename T>
    EPropertyBagResult SetValueObject(const FPropertyBagPropertyDesc& Desc, T* InValue)
    {
        static_assert(TIsDerivedFrom<T, UObject>::Value, "Should only call this with object types");
        return SetValueObject(Desc, (UObject*)InValue);
    }
 
    UE_API TValueOrError<FPropertyBagArrayRef, EPropertyBagResult> GetMutableArrayRef(const FName Name);
 
    UE_API TValueOrError<const FPropertyBagArrayRef, EPropertyBagResult> GetArrayRef(const FName Name) const;
 
    UE_API TValueOrError<FPropertyBagSetRef, EPropertyBagResult> GetMutableSetRef(const FName Name);
    
    UE_API TValueOrError<const FPropertyBagSetRef, EPropertyBagResult> GetSetRef(const FName Name) const;
 
    UE_API bool Identical(const FInstancedPropertyBag* Other, uint32 PortFlags) const;
    UE_API bool Serialize(FArchive& Ar);
    UE_API void AddStructReferencedObjects(FReferenceCollector& Collector);
    UE_API void GetPreloadDependencies(TArray<UObject*>& OutDeps);
 
    UE_API static bool IsPropertyNameValid(const FString& Name);
 
    UE_API static bool IsPropertyNameValid(const FName Name);
 
    UE_API static FName SanitizePropertyName(const FString& Name, const TCHAR ReplacementChar = TEXT('_'));
 
    UE_API static FName SanitizePropertyName(FName Name, const TCHAR ReplacementChar = TEXT('_'));
 
protected:
    UE_API const void* GetValueAddress(const FPropertyBagPropertyDesc* Desc) const;
    UE_API void* GetMutableValueAddress(const FPropertyBagPropertyDesc* Desc);
    
    UPROPERTY(EditAnywhere, Category="", meta=(SequencerUseParentPropertyName=true))
    FInstancedStruct Value;
};
 
template<> struct TStructOpsTypeTraits<FInstancedPropertyBag> : public TStructOpsTypeTraitsBase2<FInstancedPropertyBag>
{
    enum
    {
        WithIdentical = true,
        WithSerializer = true,
        WithAddStructReferencedObjects = true,
        WithGetPreloadDependencies = true,
    };
};
 
 
class FPropertyBagArrayRef : public FScriptArrayHelper
{
    FPropertyBagPropertyDesc ValueDesc;
 
    const void* GetAddress(const int32 Index) const
    {
        if (IsValidIndex(Index) == false)
        {
            return nullptr;
        }
        // Ugly, but FScriptArrayHelper does not give us other option.
        FPropertyBagArrayRef* NonConstThis = const_cast<FPropertyBagArrayRef*>(this);
        return static_cast<void*>(NonConstThis->GetRawPtr(Index));
    }
 
    void* GetMutableAddress(const int32 Index) const
    {
        if (IsValidIndex(Index) == false)
        {
            return nullptr;
        }
        // Ugly, but FScriptArrayHelper does not give us other option.
        FPropertyBagArrayRef* NonConstThis = const_cast<FPropertyBagArrayRef*>(this);
        return (void*)NonConstThis->GetRawPtr(Index);
    }
 
public: 
    inline FPropertyBagArrayRef(const FPropertyBagPropertyDesc& InDesc, const void* InArray)
        : FScriptArrayHelper(CastField<FArrayProperty>(InDesc.CachedProperty), InArray)
    {
        const FArrayProperty* ArrayProperty = CastField<FArrayProperty>(InDesc.CachedProperty);
        check(ArrayProperty);
        check(ArrayProperty->Inner);
        // Create dummy desc for the inner property. 
        ValueDesc.ValueType = InDesc.ValueType;
        ValueDesc.ValueTypeObject = InDesc.ValueTypeObject;
        ValueDesc.CachedProperty = ArrayProperty->Inner;
        ValueDesc.ContainerTypes = InDesc.ContainerTypes;
        ValueDesc.ContainerTypes.PopHead();
    }
 
    UE_API TValueOrError<bool, EPropertyBagResult> GetValueBool(const int32 Index) const;
    UE_API TValueOrError<uint8, EPropertyBagResult> GetValueByte(const int32 Index) const;
    UE_API TValueOrError<int32, EPropertyBagResult> GetValueInt32(const int32 Index) const;
    UE_API TValueOrError<uint32, EPropertyBagResult> GetValueUInt32(const int32 Index) const;
    UE_API TValueOrError<int64, EPropertyBagResult> GetValueInt64(const int32 Index) const;
    UE_API TValueOrError<uint64, EPropertyBagResult> GetValueUInt64(const int32 Index) const;
    UE_API TValueOrError<float, EPropertyBagResult> GetValueFloat(const int32 Index) const;
    UE_API TValueOrError<double, EPropertyBagResult> GetValueDouble(const int32 Index) const;
    UE_API TValueOrError<FName, EPropertyBagResult> GetValueName(const int32 Index) const;
    UE_API TValueOrError<FString, EPropertyBagResult> GetValueString(const int32 Index) const;
    UE_API TValueOrError<FText, EPropertyBagResult> GetValueText(const int32 Index) const;
    UE_API TValueOrError<uint8, EPropertyBagResult> GetValueEnum(const int32 Index, const UEnum* RequestedEnum) const;
    UE_API TValueOrError<FStructView, EPropertyBagResult> GetValueStruct(const int32 Index, const UScriptStruct* RequestedStruct = nullptr) const;
    UE_API TValueOrError<UObject*, EPropertyBagResult> GetValueObject(const int32 Index, const UClass* RequestedClass = nullptr) const;
    UE_API TValueOrError<UClass*, EPropertyBagResult> GetValueClass(const int32 Index) const;
    UE_API TValueOrError<FSoftObjectPath, EPropertyBagResult> GetValueSoftPath(const int32 Index) const;
 
    template <typename T>
    TValueOrError<T, EPropertyBagResult> GetValueEnum(const int32 Index) const
    {
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        
        TValueOrError<uint8, EPropertyBagResult> Result = GetValueEnum(Index, StaticEnum<T>());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        return MakeValue(static_cast<T>(Result.GetValue()));
    }
    
    template <typename T>
    TValueOrError<T*, EPropertyBagResult> GetValueStruct(const int32 Index) const
    {
        TValueOrError<FStructView, EPropertyBagResult> Result = GetValueStruct(Index, TBaseStructure<T>::Get());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        if (T* ValuePtr = Result.GetValue().GetPtr<T>())
        {
            return MakeValue(ValuePtr);
        }
        return MakeError(EPropertyBagResult::TypeMismatch);
    }
    
    template <typename T>
    TValueOrError<T*, EPropertyBagResult> GetValueObject(const int32 Index) const
    {
        static_assert(TIsDerivedFrom<T, UObject>::Value, "Should only call this with object types");
        
        TValueOrError<UObject*, EPropertyBagResult> Result = GetValueObject(Index, T::StaticClass());
        if (!Result.IsValid())
        {
            return MakeError(Result.GetError());
        }
        if (Result.GetValue() == nullptr)
        {
            return MakeValue(nullptr);
        }
        if (T* Object = Cast<T>(Result.GetValue()))
        {
            return MakeValue(Object);
        }
        return MakeError(EPropertyBagResult::TypeMismatch);
    }
 
    UE_API TValueOrError<FPropertyBagArrayRef, EPropertyBagResult> GetMutableNestedArrayRef(const int32 Index = 0) const;
 
    UE_API TValueOrError<const FPropertyBagArrayRef, EPropertyBagResult> GetNestedArrayRef(const int32 Index = 0) const;
 
    UE_API EPropertyBagResult SetValueBool(const int32 Index, const bool bInValue);
    UE_API EPropertyBagResult SetValueByte(const int32 Index, const uint8 InValue);
    UE_API EPropertyBagResult SetValueInt32(const int32 Index, const int32 InValue);
    UE_API EPropertyBagResult SetValueUInt32(const int32 Index, const uint32 InValue);
    UE_API EPropertyBagResult SetValueInt64(const int32 Index, const int64 InValue);
    UE_API EPropertyBagResult SetValueUInt64(const int32 Index, const uint64 InValue);
    UE_API EPropertyBagResult SetValueFloat(const int32 Index, const float InValue);
    UE_API EPropertyBagResult SetValueDouble(const int32 Index, const double InValue);
    UE_API EPropertyBagResult SetValueName(const int32 Index, const FName InValue);
    UE_API EPropertyBagResult SetValueString(const int32 Index, const FString& InValue);
    UE_API EPropertyBagResult SetValueText(const int32 Index, const FText& InValue);
    UE_API EPropertyBagResult SetValueEnum(const int32 Index, const uint8 InValue, const UEnum* Enum);
    UE_API EPropertyBagResult SetValueStruct(const int32 Index, FConstStructView InValue);
    UE_API EPropertyBagResult SetValueObject(const int32 Index, UObject* InValue);
    UE_API EPropertyBagResult SetValueClass(const int32 Index, UClass* InValue);
    UE_API EPropertyBagResult SetValueSoftPath(const int32 Index, const FSoftObjectPath& InValue);
    UE_API EPropertyBagResult SetValueSoftPath(const int32 Index, const UObject* InValue);
 
    template <typename T>
    EPropertyBagResult SetValueEnum(const int32 Index, const T InValue)
    {
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        return SetValueEnum(Index, static_cast<uint8>(InValue), StaticEnum<T>());
    }
 
    template <typename T>
    EPropertyBagResult SetValueStruct(const int32 Index, const T& InValue)
    {
        return SetValueStruct(Index, FConstStructView::Make(InValue));
    }
 
    template <typename T>
    EPropertyBagResult SetValueObject(const int32 Index, T* InValue)
    {
        static_assert(TIsDerivedFrom<T, UObject>::Value, "Should only call this with object types");
        return SetValueObject(Index, static_cast<UObject*>(InValue));
    }
};
 
class FPropertyBagSetRef : private FScriptSetHelper
{
public: 
    inline FPropertyBagSetRef(const FPropertyBagPropertyDesc& InDesc, const void* InSet)
        : FScriptSetHelper(CastField<FSetProperty>(InDesc.CachedProperty), InSet)
    {
        const FSetProperty* SetProperty = CastField<FSetProperty>(InDesc.CachedProperty);
        check(SetProperty);
        check(SetProperty->ElementProp);
        // Create dummy desc for the inner property. 
        ValueDesc.ValueType = InDesc.ValueType;
        ValueDesc.ValueTypeObject = InDesc.ValueTypeObject;
        ValueDesc.CachedProperty = SetProperty->ElementProp;
        ValueDesc.ContainerTypes = InDesc.ContainerTypes;
        ValueDesc.ContainerTypes.PopHead();
    }
 
    UE_API EPropertyBagResult AddValueBool(const bool bInValue);
    UE_API EPropertyBagResult AddValueByte(const uint8 InValue);
    UE_API EPropertyBagResult AddValueInt32(const int32 InValue);
    UE_API EPropertyBagResult AddValueUInt32(const uint32 InValue);
    UE_API EPropertyBagResult AddValueInt64(const int64 InValue);
    UE_API EPropertyBagResult AddValueUInt64(const uint64 InValue);
    UE_API EPropertyBagResult AddValueFloat(const float InValue);
    UE_API EPropertyBagResult AddValueDouble(const double InValue);
    UE_API EPropertyBagResult AddValueName(const FName InValue);
    UE_API EPropertyBagResult AddValueString(const FString& InValue);
    UE_API EPropertyBagResult AddValueText(const FText& InValue);
    UE_API EPropertyBagResult AddValueEnum(const int64 InValue, const UEnum* Enum);
    UE_API EPropertyBagResult AddValueStruct(FConstStructView InValue);
    UE_API EPropertyBagResult AddValueObject(UObject* InValue);
    UE_API EPropertyBagResult AddValueClass(UClass* InValue);
    UE_API EPropertyBagResult AddValueSoftPath(const FSoftObjectPath& InValue);
 
    template <typename T>
    EPropertyBagResult AddValueEnum(const T InValue)
    {
        static_assert(TIsEnum<T>::Value, "Should only call this with enum types");
        return AddValueEnum(static_cast<uint8>(InValue), StaticEnum<T>());
    }
 
    template <typename T>
    EPropertyBagResult AddValueStruct(const T& InValue)
    {
        return AddValueStruct(FConstStructView::Make(InValue));
    }
 
    template <typename T>
    EPropertyBagResult AddValueObject(T* InValue)
    {
        static_assert(TIsDerivedFrom<T, UObject>::Value, "Should only call this with object types");
        return AddValueObject(static_cast<UObject*>(InValue));
    }
 
 
    template <typename T>
    EPropertyBagResult Remove(const T& Value)
    {
        int32 ElementIndex = FindElementIndex(&Value);
        
        if (ElementIndex == INDEX_NONE)
        {
            return EPropertyBagResult::PropertyNotFound;
        }
 
        RemoveAt(ElementIndex);
        return EPropertyBagResult::Success;
    }
 
    template <typename T>
    TValueOrError<bool, EPropertyBagResult> Contains(const T& Value) const
    {
        if (ValueDesc.CachedProperty == nullptr)
        {
            return MakeError(EPropertyBagResult::PropertyNotFound);
        }
 
        return MakeValue(FindElementIndex(&Value) != INDEX_NONE);
    }
 
    UE_FORCEINLINE_HINT int32 Num() const
    {
        return FScriptSetHelper::Num();
    }
 
private:
 
    FPropertyBagPropertyDesc ValueDesc;
 
    template <typename T>
    EPropertyBagResult Add(const T& Value)
    {
        if (ValueDesc.CachedProperty == nullptr)
        {
            return EPropertyBagResult::PropertyNotFound;
        }
 
        int32 ElementIndex = FindElementIndex(&Value);
 
        if (ElementIndex != INDEX_NONE)
        {
            return EPropertyBagResult::DuplicatedValue;
        }
 
        AddElement(&Value);
        return EPropertyBagResult::Success;
    }
};
 
UENUM()
enum class EPropertyBagMissingEnum : uint8
{
    Missing,
};
 
USTRUCT()
struct FPropertyBagMissingStruct
{
    GENERATED_BODY()
};
 
UCLASS(MinimalAPI)
class UPropertyBagMissingObject : public UObject
{
    GENERATED_BODY()
};
 
namespace UE::Private { struct FJsonStringifyImpl; }
UCLASS(Transient, MinimalAPI)
class UPropertyBag : public UScriptStruct
{
public:
    GENERATED_BODY()
 
    
    static UE_API const UPropertyBag* GetOrCreateFromDescs(const TConstArrayView<FPropertyBagPropertyDesc> InPropertyDescs, const TCHAR* PrefixName = nullptr);
 
    TConstArrayView<FPropertyBagPropertyDesc> GetPropertyDescs() const { return PropertyDescs; }
 
    UE_API const FPropertyBagPropertyDesc* FindPropertyDescByID(const FGuid ID) const;
 
    UE_API const FPropertyBagPropertyDesc* FindPropertyDescByName(const FName Name) const;
 
    UE_API const FPropertyBagPropertyDesc* FindPropertyDescByPropertyName(const FName PropertyName) const;
 
    UE_API const FPropertyBagPropertyDesc* FindPropertyDescByProperty(const FProperty* Property) const;
 
    UE_API const FPropertyBagPropertyDesc* FindPropertyDescByIndex(int32 Index) const;
 
    UE_API bool OwnsPropertyDesc(const FPropertyBagPropertyDesc& Desc) const;
 
#if WITH_EDITOR
    UE_API bool ContainsUserDefinedStruct(const UUserDefinedStruct* UserDefinedStruct) const;
#endif // WITH_EDITOR
    
protected:
 
    UE_API void DecrementRefCount() const;
    UE_API void IncrementRefCount() const;
    
    UE_API virtual void InitializeStruct(void* Dest, int32 ArrayDim = 1) const override;
    UE_API virtual void DestroyStruct(void* Dest, int32 ArrayDim = 1) const override;
    UE_API virtual void FinishDestroy() override;
    
    UPROPERTY()
    TArray<FPropertyBagPropertyDesc> PropertyDescs;
 
    std::atomic<int32> RefCount = 0;
    
    // both of these types need to serialize their property bag:
    friend struct FInstancedPropertyBag;
    friend struct ::UE::Private::FJsonStringifyImpl;
};
 
#undef UE_API