AttributeStorage.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/EnumAsByte.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "HAL/CriticalSection.h"
#include "Internationalization/Text.h"
#include "Math/Box.h"
#include "Math/Box2D.h"
#include "Math/BoxSphereBounds.h"
#include "Math/Color.h"
#include "Math/Float16.h"
#include "Math/IntPoint.h"
#include "Math/IntRect.h"
#include "Math/IntVector.h"
#include "Math/MathFwd.h"
#include "Math/Matrix.h"
#include "Math/OrientedBox.h"
#include "Math/Plane.h"
#include "Math/Quat.h"
#include "Math/RandomStream.h"
#include "Math/Rotator.h"
#include "Math/Sphere.h"
#include "Math/Sphere.h"
#include "Math/Transform.h"
#include "Math/TwoVectors.h"
#include "Math/Vector.h"
#include "Math/Vector2D.h"
#include "Math/Vector2DHalf.h"
#include "Math/Vector4.h"
#include "Misc/DateTime.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/Guid.h"
#include "Misc/Timespan.h"
#include "Serialization/Archive.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/SoftObjectPath.h"
 
#include "InterchangeCustomVersion.h"
 
//Interchange namespace
namespace UE
{
    namespace Interchange
    {
        namespace Private
        {
            template <typename T, typename Enable = void>
            struct UE_DEPRECATED(5.7, "No longer used.") TUnderlyingType {};
 
            template <typename T>
            struct UE_DEPRECATED(5.7, "No longer used.") TUnderlyingType<T, typename std::enable_if<std::is_enum<T>::value>::type>
            {
                using type = typename std::underlying_type<T>::type;
            };
        }
 
        struct FAttributeKey
        {
            FString Key;
 
            FAttributeKey() = default;
        
            FAttributeKey(const FAttributeKey& Other) = default;
            FAttributeKey(FAttributeKey&& Other) = default;
            FAttributeKey& operator=(const FAttributeKey&) = default;
            FAttributeKey& operator=(FAttributeKey&&) = default;
 
            explicit FAttributeKey(const FName& Other)
            {
                Key = Other.ToString();
            }
 
            explicit FAttributeKey(const FStringView& Other)
            {
                Key = Other;
            }
 
            explicit FAttributeKey(const FString& Other)
            {
                Key = Other;
            }
 
            explicit FAttributeKey(FString&& Other)
            {
                Key = MoveTemp(Other);
            }
 
            explicit FAttributeKey(const FText& Other)
            {
                Key = Other.ToString();
            }
 
            explicit FAttributeKey(const TCHAR* Other)
            {
                Key = Other;
            }
 
            inline FAttributeKey& operator=(const FName& Other)
            {
                Key = Other.ToString();
                return *this;
            }
 
            inline FAttributeKey& operator=(const FString& Other)
            {
                Key = Other;
                return *this;
            }
 
            inline FAttributeKey& operator=(FString&& Other)
            {
                Key = MoveTemp(Other);
                return *this;
            }
 
            inline FAttributeKey& operator=(const FText& Other)
            {
                Key = Other.ToString();
                return *this;
            }
 
            inline FAttributeKey& operator=(const TCHAR* Other)
            {
                Key = Other;
                return *this;
            }
        
            inline bool operator==(const FAttributeKey& Other) const
            {
                return Key.Equals(Other.Key);
            }
 
            inline bool operator!=(const FAttributeKey& Other) const
            {
                return !Key.Equals(Other.Key);
            }
 
            inline bool operator<(const FAttributeKey& Other) const
            {
                return Key.Compare(Other.Key) < 0;
            }
 
            inline bool operator<=(const FAttributeKey& Other) const
            {
                return Key.Compare(Other.Key) <= 0;
            }
 
            inline bool operator>(const FAttributeKey& Other) const
            {
                return Key.Compare(Other.Key) > 0;
            }
 
            inline bool operator>=(const FAttributeKey& Other) const
            {
                return Key.Compare(Other.Key) >= 0;
            }
 
            friend FArchive& operator<<(FArchive& Ar, FAttributeKey& AttributeKey)
            {
                Ar << AttributeKey.Key;
                return Ar;
            }
 
            inline const FString& ToString() const
            {
                return Key;
            }
 
            inline FName ToName() const
            {
                return FName(*Key);
            }
        };
 
        using ::GetTypeHash;
        inline uint32 GetTypeHash(const FAttributeKey& AttributeKey)
        {
            return GetTypeHash(AttributeKey.Key);
        }
 
 
        enum class EAttributeTypes : int32
        {
            None                    = 0,
 
            Bool                    = 1,
            Color                   = 4,
            DateTime                = 5,
            Double                  = 6,
            Enum                    = 7,
            Float                   = 8,
            Guid                    = 9,
            Int8                    = 10,
            Int16                   = 11,
            Int32                   = 12,
            Int64                   = 13,
            IntRect                 = 14,
            LinearColor             = 15,
            Name                    = 16,
            RandomStream            = 17,
            String                  = 18,
            Timespan                = 19,
            TwoVectors              = 20,
            UInt8                   = 21,
            UInt16                  = 22,
            UInt32                  = 23,
            UInt64                  = 24,
            Vector2d                = 25,
            IntPoint                = 26,
            IntVector               = 27,
            Vector2DHalf            = 28,
            Float16                 = 29,
            OrientedBox             = 30,
            FrameNumber             = 31,
            FrameRate               = 32,
            FrameTime               = 33,
            SoftObjectPath          = 34,
            Matrix44f               = 35,
            Matrix44d               = 36,
            Plane4f                 = 37,
            Plane4d                 = 38,
            Quat4f                  = 39,
            Quat4d                  = 40,
            Rotator3f               = 41,
            Rotator3d               = 42,
            Transform3f             = 43,
            Transform3d             = 44,
            Vector3f                = 45,
            Vector3d                = 46,
            Vector2f                = 47,
            Vector4f                = 48,
            Vector4d                = 49,
            Box2f                   = 50,
            Box2D                   = 51,
            Box3f                   = 52,
            Box3d                   = 53,
            BoxSphereBounds3f       = 54,
            BoxSphereBounds3d       = 55,
            Sphere3f                = 56,
            Sphere3d                = 57,
 
            BoolArray               = 58,
            ColorArray              = 59,
            DateTimeArray           = 60,
            DoubleArray             = 61,
            EnumArray               = 62,
            FloatArray              = 63,
            GuidArray               = 64,
            Int8Array               = 65,
            Int16Array              = 66,
            Int32Array              = 67,
            Int64Array              = 68,
            IntRectArray            = 69,
            LinearColorArray        = 70,
            NameArray               = 71,
            RandomStreamArray       = 72,
            StringArray             = 73,
            TimespanArray           = 74,
            TwoVectorsArray         = 75,
            ByteArray               = 2,
            ByteArray64             = 3,
            UInt16Array             = 76,
            UInt32Array             = 77,
            UInt64Array             = 78,
            Vector2dArray           = 79,
            IntPointArray           = 80,
            IntVectorArray          = 81,
            Vector2DHalfArray       = 82,
            Float16Array            = 83,
            OrientedBoxArray        = 84,
            FrameNumberArray        = 85,
            FrameRateArray          = 86,
            FrameTimeArray          = 87,
            SoftObjectPathArray     = 88,
            Matrix44fArray          = 89,
            Matrix44dArray          = 90,
            Plane4fArray            = 91,
            Plane4dArray            = 92,
            Quat4fArray             = 93,
            Quat4dArray             = 94,
            Rotator3fArray          = 95,
            Rotator3dArray          = 96,
            Transform3fArray        = 97,
            Transform3dArray        = 98,
            Vector3fArray           = 99,
            Vector3dArray           = 100,
            Vector2fArray           = 101,
            Vector4fArray           = 102,
            Vector4dArray           = 103,
            Box2fArray              = 104,
            Box2DArray              = 105,
            Box3fArray              = 106,
            Box3dArray              = 107,
            BoxSphereBounds3fArray  = 108,
            BoxSphereBounds3dArray  = 109,
            Sphere3fArray           = 110,
            Sphere3dArray           = 111,
 
            //Max should always be updated if we add a new supported type
            Max                     = 112
        };
 
        INTERCHANGECORE_API FString AttributeTypeToString(EAttributeTypes AttributeType);
 
        INTERCHANGECORE_API EAttributeTypes StringToAttributeType(const FString& AttributeTypeString);
 
        template<typename T, typename Enable = void>
        struct UE_DEPRECATED(5.7, "No longer used: The AttributeStorage handles all supported type traits internally now.") TAttributeTypeTraits
        {
            static constexpr EAttributeTypes GetType()
            {
                return EAttributeTypes::None;
            }
 
            template<typename ValueType>
            static FString ToString(const ValueType& Value)
            {
                return TEXT("Unknown type");
            }
        };
 
        template<typename ValueType>
        INTERCHANGECORE_API FString AttributeValueToString(const ValueType& Value);
 
        enum class EAttributeStorageResult : uint64
        {
            None                                            = 0x0,
            //Success result.
            Operation_Success                               = 0x1,
        
 
            //Operation error results from here.
 
            //The type of the value was not matching the existing type. We cannot change the type of an existing attribute.
            Operation_Error_WrongType                       = (0x1 << 20),
            //The size of the value is different from the existing size. We cannot have a different size.
            Operation_Error_WrongSize                       = (0x1 << 21),
            //The AttributeAllocationTable has an attribute whose offset is not valid in the storage.
            Operation_Error_AttributeAllocationCorrupted    = (0x1 << 22),
            //We cannot find the specified key.
            Operation_Error_CannotFoundKey                  = (0x1 << 23),
            //There was an error when removing an attribute from the AttributeAllocationTable. The TArray remove has failed.
            Operation_Error_CannotRemoveAttribute           = (0x1 << 24),
            //We try to override an attribute but the specified options do not allow override.
            Operation_Error_CannotOverrideAttribute         = (0x1 << 25),
            //The storage is invalid (nullptr).
            Operation_Error_InvalidStorage                  = (0x1 << 26),
            //Cannot get a valid value data pointer.
            Operation_Error_InvalidMultiSizeValueData       = (0x1 << 27),
        };
 
        ENUM_CLASS_FLAGS(EAttributeStorageResult)
 
        
        inline bool HasAttributeStorageResult(const EAttributeStorageResult Result, const EAttributeStorageResult RefResult)
        {
            return ((Result & RefResult) != EAttributeStorageResult::None);
        }
    
        inline bool IsAttributeStorageResultSuccess(const EAttributeStorageResult Result)
        {
            return HasAttributeStorageResult(Result, EAttributeStorageResult::Operation_Success);
        }
 
        INTERCHANGECORE_API void LogAttributeStorageErrors(const EAttributeStorageResult Result, const FString OperationName, const FAttributeKey AttributeKey );
 
 
        enum class EAttributeStorageAddOptions : uint32
        {
            None                    = 0x0,
            Option_Override         = 0x1,
            //allow the AddAttribute to override the value if it exists.
        };
 
        ENUM_CLASS_FLAGS(EAttributeStorageAddOptions)
 
        
        inline bool HasAttributeStorageAddOption(const EAttributeStorageAddOptions Options, const EAttributeStorageAddOptions RefOptions)
        {
            return ((Options & RefOptions) != EAttributeStorageAddOptions::None);
        }
 
        enum class EAttributeProperty : uint32
        {
            None                        = 0x0,
            NoHash                      = 0x1, /* No hash attribute will not be part of the hash result when calling GetStorageHash. */
        };
 
        ENUM_CLASS_FLAGS(EAttributeProperty)
 
        
        inline bool HasAttributeProperty(const EAttributeProperty PropertyA, const EAttributeProperty PropertyB)
        {
            return ((PropertyA & PropertyB) != EAttributeProperty::None);
        }
 
        template<typename T>
        struct UE_DEPRECATED(5.7, "No longer used.") TSpecializeType
        {
            typedef T Type;
        };
 
        template<typename T>
        struct TAttributeStorageTypeTraits
        {
            static constexpr bool bIsArrayOfStringType = false;
            static constexpr bool bIsArrayOfEnumType = false;
            static constexpr bool bIsArrayOfEnumAsByteType = false;
        };
 
        template<typename T>
        inline constexpr bool TIsStringType = std::is_same_v<T, FString> || std::is_same_v<T, FName> || std::is_same_v<T, FSoftObjectPath>;
 
        template<typename T>
        inline constexpr bool TIsArrayOfStringType = TAttributeStorageTypeTraits<T>::bIsArrayOfStringType;
 
        template<typename T>
        inline constexpr bool TIsArrayOfEnumType = TAttributeStorageTypeTraits<T>::bIsArrayOfEnumType;
 
        template<typename T>
        inline constexpr bool TIsArrayOfEnumAsByteType = TAttributeStorageTypeTraits<T>::bIsArrayOfEnumAsByteType;
 
        template<typename T>
        inline constexpr bool TIsNonEnumType = !TIsEnum<T>::Value && !TIsTEnumAsByte<T>::Value && !TIsArrayOfEnumType<T> && !TIsArrayOfEnumAsByteType<T>;
 
        template<typename T>
        struct TAttributeStorageTypeTraits<TArray<T>>
        {
            using ElementType = T;
 
            static constexpr bool bIsArrayOfStringType = TIsStringType<ElementType>;
            static constexpr bool bIsArrayOfEnumType = TIsEnum<ElementType>::Value;
            static constexpr bool bIsArrayOfEnumAsByteType = TIsTEnumAsByte<ElementType>::Value;
        };
 
        class FAttributeStorage
        {
        public:
            template<typename T, typename Enable = void>
            class TAttributeHandle;
 
            template<typename T>
            class TAttributeHandle<T, std::enable_if_t<TIsNonEnumType<T>>>
            {
            public:
                INTERCHANGECORE_API TAttributeHandle();
 
                INTERCHANGECORE_API bool IsValid() const;
            
                INTERCHANGECORE_API EAttributeStorageResult Get(T& Value) const;
 
                INTERCHANGECORE_API EAttributeStorageResult Set(const T& Value);
 
                INTERCHANGECORE_API const FAttributeKey& GetKey() const;
 
            protected:
                class FAttributeStorage* AttributeStorage;
                FAttributeKey Key;
            
                INTERCHANGECORE_API TAttributeHandle(const FAttributeKey& InKey, const FAttributeStorage* InAttributeStorage);
 
                friend FAttributeStorage;
            };
 
            // Redirect enum instantiations to underlying type
            template<typename E>
            class TAttributeHandle<E, std::enable_if_t<TIsEnum<E>::Value>>
                : public TAttributeHandle<std::underlying_type_t<E>>
            {
            public:
                using UnderlyingType = std::underlying_type_t<E>;
                using Base = TAttributeHandle<UnderlyingType>;
 
                using Base::Base;
 
                explicit TAttributeHandle(const TAttributeHandle<UnderlyingType>& Other)
                    : TAttributeHandle(Other.Key, Other.AttributeStorage)
                {
                }
 
                // Note: Since we derive TAttributeHandle<std::underlying_type_t<E>> we also get the
                // base class overloads for free, and can Get()/Set() with the underlying type directly!
                EAttributeStorageResult Get(E& Value) const
                {
                    return Base::Get((UnderlyingType&)Value);
                }
 
                EAttributeStorageResult Set(const E& Value)
                {
                    return Base::Set((const UnderlyingType&)Value);
                }
 
            protected:
                friend FAttributeStorage;
            };
 
            // Redirect TEnumAsByte<T> instantiations to uint8
            template<typename B>
            class TAttributeHandle<B, std::enable_if_t<TIsTEnumAsByte<B>::Value>>
                : public TAttributeHandle<uint8>
            {
            public:
                using UnderlyingType = uint8;
                using Base = TAttributeHandle<UnderlyingType>;
 
                using Base::Base;
 
                explicit TAttributeHandle(const TAttributeHandle<UnderlyingType>& Other)
                    : TAttributeHandle(Other.Key, Other.AttributeStorage)
                {
                }
 
                EAttributeStorageResult Get(B& Value) const
                {
                    return Base::Get((UnderlyingType&)Value);
                }
 
                EAttributeStorageResult Set(const B& Value)
                {
                    return Base::Set((const UnderlyingType&)Value);
                }
 
            protected:
                friend FAttributeStorage;
            };
 
            // Redirect TArray<enum> instantiations to TArray<underlying type>
            template<typename T>
            class TAttributeHandle<T, std::enable_if_t<TIsArrayOfEnumType<T>>>
                : public TAttributeHandle<TArray<std::underlying_type_t<typename T::ElementType>>>
            {
            public:
                using UnderlyingType = std::underlying_type_t<typename T::ElementType>;
                using Base = TAttributeHandle<TArray<UnderlyingType>>;
 
                using Base::Base;
 
                explicit TAttributeHandle(const TAttributeHandle<TArray<UnderlyingType>>& Other)
                    : TAttributeHandle(Other.Key, Other.AttributeStorage)
                {
                }
 
                EAttributeStorageResult Get(T& Value) const
                {
                    return Base::Get((TArray<UnderlyingType>&)Value);
                }
 
                EAttributeStorageResult Set(const T& Value)
                {
                    return Base::Set((const TArray<UnderlyingType>&)Value);
                }
 
            protected:
                friend FAttributeStorage;
            };
 
            // Redirect TArray<TEnumAsByte<T>> instantiations to TArray<uint8>
            template<typename T>
            class TAttributeHandle<T, std::enable_if_t<TIsArrayOfEnumAsByteType<T>>>
                : public TAttributeHandle<TArray<uint8>>
            {
            public:
                using UnderlyingType = uint8;
                using Base = TAttributeHandle<TArray<UnderlyingType>>;
 
                using Base::Base;
 
                explicit TAttributeHandle(const TAttributeHandle<TArray<UnderlyingType>>& Other)
                    : TAttributeHandle(Other.Key, Other.AttributeStorage)
                {
                }
 
                EAttributeStorageResult Get(T& Value) const
                {
                    return Base::Get((TArray<UnderlyingType>&)Value);
                }
 
                EAttributeStorageResult Set(const T& Value)
                {
                    return Base::Set((const TArray<UnderlyingType>&)Value);
                }
 
            protected:
                friend FAttributeStorage;
            };
 
            FAttributeStorage() = default;
 
            INTERCHANGECORE_API FAttributeStorage(const FAttributeStorage& Other);
 
            INTERCHANGECORE_API FAttributeStorage& operator=(const FAttributeStorage& Other);
 
            template<typename T, typename = std::enable_if_t<TIsNonEnumType<T>>>
            INTERCHANGECORE_API EAttributeStorageResult RegisterAttribute(const FAttributeKey& ElementAttributeKey, const T& DefaultValue, EAttributeProperty AttributeProperty = EAttributeProperty::None);
 
            // Redirect enum instantiations to underlying type
            template<typename E, typename = std::enable_if_t<TIsEnum<E>::Value>, int = 0>
            EAttributeStorageResult RegisterAttribute(const FAttributeKey& ElementAttributeKey, const E& DefaultValue, EAttributeProperty AttributeProperty = EAttributeProperty::None)
            {
                using UnderlyingType = std::underlying_type_t<E>;
                return RegisterAttribute<UnderlyingType>(ElementAttributeKey, (const UnderlyingType&)DefaultValue, AttributeProperty);
            }
 
            // Redirect TEnumAsByte instantiations to underlying type
            template<typename B, typename = std::enable_if_t<TIsTEnumAsByte<B>::Value>, int = 0, int = 0>
            EAttributeStorageResult RegisterAttribute(const FAttributeKey& ElementAttributeKey, const B& DefaultValue, EAttributeProperty AttributeProperty = EAttributeProperty::None)
            {
                using UnderlyingType = uint8;
                return RegisterAttribute<UnderlyingType>(ElementAttributeKey, (const UnderlyingType&)DefaultValue, AttributeProperty);
            }
 
            // Redirect TArray<enum> instantiations to TArray<underlying type>
            template<typename T, typename = std::enable_if_t<TIsArrayOfEnumType<T>>, int = 0, int = 0, int = 0>
            EAttributeStorageResult RegisterAttribute(const FAttributeKey& ElementAttributeKey, const T& DefaultValue, EAttributeProperty AttributeProperty = EAttributeProperty::None)
            {
                using UnderlyingType = std::underlying_type_t<typename T::ElementType>;
                return RegisterAttribute<TArray<UnderlyingType>>(ElementAttributeKey, (const TArray<UnderlyingType>&)DefaultValue, AttributeProperty);
            }
 
            // Redirect TArray<TEnumAsByte> instantiations to TArray<underlying type>
            template<typename T, typename = std::enable_if_t<TIsArrayOfEnumAsByteType<T>>, int = 0, int = 0, int = 0, int = 0>
            EAttributeStorageResult RegisterAttribute(const FAttributeKey& ElementAttributeKey, const T& DefaultValue, EAttributeProperty AttributeProperty = EAttributeProperty::None)
            {
                using UnderlyingType = uint8;
                return RegisterAttribute<TArray<uint8>>(ElementAttributeKey, (const TArray<uint8>&)DefaultValue, AttributeProperty);
            }
 
            INTERCHANGECORE_API EAttributeStorageResult UnregisterAttribute(const FAttributeKey& ElementAttributeKey);
 
            template<typename T, typename = std::enable_if_t<TIsNonEnumType<T>>>
            INTERCHANGECORE_API EAttributeStorageResult GetAttribute(const FAttributeKey& ElementAttributeKey, T& OutValue) const;
 
            // Redirect enum instantiations to underlying type
            template<typename E, typename = std::enable_if_t<TIsEnum<E>::Value>, int = 0>
            EAttributeStorageResult GetAttribute(const FAttributeKey& ElementAttributeKey, E& OutValue) const
            {
                using UnderlyingType = std::underlying_type_t<E>;
                return GetAttribute<UnderlyingType>(ElementAttributeKey, OutValue);
            }
 
            // Redirect TEnumAsByte instantiations to underlying type
            template<typename B, typename = std::enable_if_t<TIsTEnumAsByte<B>::Value>, int = 0, int = 0>
            EAttributeStorageResult GetAttribute(const FAttributeKey& ElementAttributeKey, B& OutValue) const
            {
                using UnderlyingType = uint8;
                return GetAttribute<UnderlyingType>(ElementAttributeKey, OutValue);
            }
 
            // Redirect TArray<enum> instantiations to TArray<underlying type>
            template<typename ArrayOfE, typename = std::enable_if_t<TIsArrayOfEnumType<ArrayOfE>>, int = 0, int = 0, int = 0>
            EAttributeStorageResult GetAttribute(const FAttributeKey& ElementAttributeKey, ArrayOfE& OutValue) const
            {
                using UnderlyingType = std::underlying_type_t<typename ArrayOfE::ElementType>;
                return GetAttribute<TArray<UnderlyingType>>(ElementAttributeKey, (TArray<UnderlyingType>&)OutValue);
            }
 
            // Redirect TArray<TEnumAsByte> instantiations to TArray<uint8>
            template<typename ArrayOfB, typename = std::enable_if_t<TIsArrayOfEnumAsByteType<ArrayOfB>>, int = 0, int = 0, int = 0, int = 0>
            EAttributeStorageResult GetAttribute(const FAttributeKey& ElementAttributeKey, ArrayOfB& OutValue) const
            {
                using UnderlyingType = uint8;
                return GetAttribute<TArray<uint8>>(ElementAttributeKey, (TArray<uint8>&)OutValue);
            }
 
            template<typename T, typename = std::enable_if_t<TIsNonEnumType<T>>>
            INTERCHANGECORE_API TAttributeHandle<T> GetAttributeHandle(const FAttributeKey& ElementAttributeKey) const;
 
            // Redirect enum instantiations to underlying type
            template<typename E, typename = std::enable_if_t<TIsEnum<E>::Value>, int = 0>
            TAttributeHandle<E> GetAttributeHandle(const FAttributeKey& ElementAttributeKey) const
            {
                using UnderlyingType = std::underlying_type_t<E>;
                return (TAttributeHandle<E>)GetAttributeHandle<UnderlyingType>(ElementAttributeKey);
            }
 
            // Redirect TEnumAsByte instantiations to underlying type
            template<typename B, typename = std::enable_if_t<TIsTEnumAsByte<B>::Value>, int = 0, int = 0>
            TAttributeHandle<B> GetAttributeHandle(const FAttributeKey& ElementAttributeKey) const
            {
                using UnderlyingType = uint8;
                return (TAttributeHandle<B>)GetAttributeHandle<UnderlyingType>(ElementAttributeKey);
            }
 
            // Redirect TArray<enum> instantiations to TArray<underlying type>
            template<typename ArrayOfE, typename = std::enable_if_t<TIsArrayOfEnumType<ArrayOfE>>, int = 0, int = 0, int = 0>
            TAttributeHandle<ArrayOfE> GetAttributeHandle(const FAttributeKey& ElementAttributeKey) const
            {
                using UnderlyingType = std::underlying_type_t<typename ArrayOfE::ElementType>;
                return (TAttributeHandle<ArrayOfE>)GetAttributeHandle<TArray<UnderlyingType>>(ElementAttributeKey);
            }
 
            // Redirect TArray<TEnumAsByte> instantiations to TArray<uint8>
            template<typename ArrayOfB, typename = std::enable_if_t<TIsArrayOfEnumAsByteType<ArrayOfB>>, int = 0, int = 0, int = 0, int = 0>
            TAttributeHandle<ArrayOfB> GetAttributeHandle(const FAttributeKey& ElementAttributeKey) const
            {
                using UnderlyingType = uint8;
                return (TAttributeHandle<ArrayOfB>)GetAttributeHandle<TArray<UnderlyingType>>(ElementAttributeKey);
            }
 
            INTERCHANGECORE_API EAttributeTypes GetAttributeType(const FAttributeKey& ElementAttributeKey) const;
 
            INTERCHANGECORE_API bool ContainAttribute(const FAttributeKey& ElementAttributeKey) const;
 
            INTERCHANGECORE_API void GetAttributeKeys(TArray<FAttributeKey>& AttributeKeys) const;
    
            INTERCHANGECORE_API FGuid GetAttributeHash(const FAttributeKey& ElementAttributeKey) const;
    
            INTERCHANGECORE_API bool GetAttributeHash(const FAttributeKey& ElementAttributeKey, FGuid& OutGuid) const;
 
            INTERCHANGECORE_API FGuid GetStorageHash() const;
 
            static INTERCHANGECORE_API void CompareStorage(const FAttributeStorage& BaseStorage, const FAttributeStorage& VersionStorage, TArray<FAttributeKey>& RemovedAttributes, TArray<FAttributeKey>& AddedAttributes, TArray<FAttributeKey>& ModifiedAttributes);
 
            static INTERCHANGECORE_API void CopyStorageAttributes(const FAttributeStorage& SourceStorage, FAttributeStorage& DestinationStorage, const TArray<FAttributeKey>& AttributeKeys);
 
            static INTERCHANGECORE_API void CopyStorageAttributes(const FAttributeStorage& SourceStorage, FAttributeStorage& DestinationStorage, const TArray<TPair<FAttributeKey, FAttributeKey>>& SrcDestAttributeKeys);
 
            inline float GetDefragRatio() const
            {
                return DefragRatio;
            }
    
            INTERCHANGECORE_API void SetDefragRatio(const float InDefragRatio);
    
            friend FArchive& operator<<(FArchive& Ar, FAttributeStorage& Storage)
            {
                Ar << Storage.FragmentedMemoryCost;
                Ar << Storage.DefragRatio;
                Ar << Storage.AttributeAllocationTable;
                Ar << Storage.AttributeStorage;
 
                if (Ar.IsLoading())
                {
                    Storage.UpdateAllocationCount();
                }
 
                return Ar;
            }
 
            INTERCHANGECORE_API void Reserve(int64 NewAttributeCount, int64 NewStorageSize);
 
        protected:
            struct FAttributeAllocationInfo
            {
                // clang fix for std::is_default_constructible_v 
                // returning false in inlined code of outer class
                FAttributeAllocationInfo() {}
                
                //The offsets of our allocations in the storage
                TArray<uint64> Offsets;
                //The sizes of our allocations in the storage, in bytes
                TArray<uint64> Sizes;
                //The real type of the attribute
                EAttributeTypes Type = EAttributeTypes::None;
                //The attribute properties
                EAttributeProperty Property = EAttributeProperty::None;
                //128 bit Attribute hash
                FGuid Hash = FGuid();
 
                bool operator==(const FAttributeAllocationInfo& Other) const
                {
                    //Offset is a unique key
                    return Offsets == Other.Offsets
                        && Sizes == Other.Sizes
                        && Type == Other.Type
                        && Property == Other.Property
                        && Hash == Other.Hash;
                }
            
                //Serialization
                friend FArchive& operator<<(FArchive& Ar, FAttributeAllocationInfo& AttributeAllocationInfo)
                {
                    Ar.UsingCustomVersion(FInterchangeCustomVersion::GUID);
 
                    if (Ar.IsLoading()
                        && Ar.CustomVer(FInterchangeCustomVersion::GUID) < FInterchangeCustomVersion::MultipleAllocationsPerAttributeInStorageFixed)
                    {
                        uint64 OldOffset;
                        Ar << OldOffset;
                        AttributeAllocationInfo.Offsets = {OldOffset};
 
                        uint64 OldSize;
                        Ar << OldSize;
                        AttributeAllocationInfo.Sizes = {OldSize};
                    }
                    else
                    {
                        Ar << AttributeAllocationInfo.Offsets;
                        Ar << AttributeAllocationInfo.Sizes;
                    }
 
                    Ar << AttributeAllocationInfo.Type;
                    Ar << AttributeAllocationInfo.Property;
                    Ar << AttributeAllocationInfo.Hash;
                    return Ar;
                }
            };
 
            INTERCHANGECORE_API bool AreAllocationInfosEqual(const FAttributeKey& BaseKey, const FAttributeAllocationInfo& BaseInfo, const FAttributeStorage& VersionStorage, const FAttributeAllocationInfo& VersionInfo) const;
 
            template<typename T>
            EAttributeStorageResult SetAttribute(const FAttributeKey& ElementAttributeKey, const T& Value);
 
            template<typename T>
            EAttributeStorageResult SetAttribute(FAttributeAllocationInfo* AttributeAllocationInfo, const T& Value);
 
            void DefragInternal();
 
            template<typename T>
            UE_DEPRECATED(5.7, "No longer used.")
            static uint64 GetValueSize(const T& Value)
            {
                return 1;
            }
 
            const FStringView GetFStringViewAttributeFromStorage(const uint8* StorageData, const FAttributeAllocationInfo* AttributeAllocationInfo, int32 ElementIndex = 0) const;
 
            template<typename MultiSizeType>
            EAttributeStorageResult MultiSizeSetAttribute(FAttributeAllocationInfo* AttributeAllocationInfo, int32 TargetAllocationIndex, const MultiSizeType& Value, const uint8* SourceDataPtr, bool& bOutNeedsDefrag);
 
            template<typename ArrayType>
            EAttributeStorageResult GenericArrayGetAttribute(const FAttributeKey& ElementAttributeKey, ArrayType& OutValue) const;
 
            template<typename T>
            friend void CopyStorageAttributesInternal(const FAttributeStorage& SourceStorage, FAttributeStorage& DestinationStorage, const TArray<T>& AttributeKeys);
 
            void UpdateAllocationInfoHash(FAttributeAllocationInfo& AllocationInfo);
 
            void UpdateAllocationCount();
 
            TMap<FAttributeKey, FAttributeAllocationInfo> AttributeAllocationTable;
 
            TArray64<uint8> AttributeStorage;
 
            uint64 FragmentedMemoryCost = 0;
 
            float DefragRatio = 0.1f;
 
            uint32 AllocationCount = 0;
 
            mutable FCriticalSection StorageMutex;
        };
    } //ns interchange
}