StructTypeBitSet.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/BitArray.h"
#include "Misc/StringOutputDevice.h"
#include "StructUtils/StructUtilsTypes.h"
#include "StructUtils/InstancedStruct.h"
#include "Templates/FunctionFwd.h"
 
#define UE_API COREUOBJECT_API
 
class FArchive;
 
namespace FStructTypeBitSet
{
 
struct FConstBitSetContainer : TBitArray<>
{
    using Super = TBitArray<>;
 
    FConstBitSetContainer() = default;
 
    inline bool HasAll(const TBitArray<>& Other) const
    {
        FConstWordIterator ThisIterator(*this);
        FConstWordIterator OtherIterator(Other);
 
        while (ThisIterator || OtherIterator)
        {
            const uint32 A = ThisIterator ? ThisIterator.GetWord() : 0;
            const uint32 B = OtherIterator ? OtherIterator.GetWord() : 0;
            if ((A & B) != B)
            {
                return false;
            }
 
            ++ThisIterator;
            ++OtherIterator;
        }
 
        return true;
    }
 
    inline bool HasAny(const TBitArray<>& Other) const
    {
        FConstWordIterator ThisIterator(*this);
        FConstWordIterator OtherIterator(Other);
 
        while (ThisIterator || OtherIterator)
        {
            const uint32 A = ThisIterator ? ThisIterator.GetWord() : 0;
            const uint32 B = OtherIterator ? OtherIterator.GetWord() : 0;
            if ((A & B) != 0)
            {
                return true;
            }
 
            ++ThisIterator;
            ++OtherIterator;
        }
 
        return false;
    }
 
    inline bool IsEmpty() const
    {
        FConstWordIterator Iterator(*this);
 
        while (Iterator && Iterator.GetWord() == 0)
        {
            ++Iterator;
        }
 
        return !Iterator;
    }
 
    bool operator==(const FConstBitSetContainer& Other) const
    {
        return (IsEmpty() && Other.IsEmpty()) || Super::operator==(Other);
    }
 
    inline friend uint32 GetTypeHash(const FConstBitSetContainer& Instance)
    {
        FConstWordIterator Iterator(Instance);
        uint32 Hash = 0;
        uint32 TrailingZeroHash = 0;
        while (Iterator)
        {
            const uint32 Word = Iterator.GetWord();
            if (Word)
            {
                Hash = HashCombine(TrailingZeroHash ? TrailingZeroHash : Hash, Word);
                TrailingZeroHash = 0;
            }
            else // potentially a trailing 0-word
            {
                TrailingZeroHash = HashCombine(TrailingZeroHash ? TrailingZeroHash : Hash, Word);
            }
            ++Iterator;
        }
        return Hash;
    }
 
    bool Contains(const int32 Index) const
    {
        check(Index >= 0);
        return (Index < Num()) && (*this)[Index];
    }
 
    int32 CountStoredTypes() const
    {
        return CountSetBits();
    }
 
protected:
    explicit FConstBitSetContainer(const TBitArray<>& Source)
        : Super(Source)
    {
    }
 
    explicit FConstBitSetContainer(TBitArray<>&& Source)
        : Super(Forward<TBitArray<>>(Source))
    {
    }
};
 
struct FBitSetContainer : FConstBitSetContainer
{
    using FConstBitSetContainer::FConstBitSetContainer;
 
    FBitSetContainer() = default;
 
    explicit FBitSetContainer(const TBitArray<>& Source)
        : FConstBitSetContainer(Source)
    {
    }
    explicit FBitSetContainer(TBitArray<>&& Source)
        : FConstBitSetContainer(Forward<TBitArray<>>(Source))
    {
    }
 
    FBitSetContainer& operator=(const TBitArray<>& Other)
    {
        static_assert(sizeof(FBitSetContainer) == sizeof(TBitArray<>)
            , "This operator requires FBitSetContainer and TBitArray<> sizes to match (i.e. FBitSetContainer cannot have member variables nor virtual funtions)");
        *((TBitArray<>*)this) = Other;
        return *this;
    }
 
 
    void SetAll(const bool bValue, const int32 Count)
    {
        Init(bValue, Count);
    }
 
    inline void operator-=(const TBitArray<>& Other)
    {
        FWordIterator ThisIterator(*this);
        FConstWordIterator OtherIterator(Other);
 
        while (ThisIterator && OtherIterator)
        {
            ThisIterator.SetWord(ThisIterator.GetWord() & ~OtherIterator.GetWord());
 
            ++ThisIterator;
            ++OtherIterator;
        }
    }
 
    void AddAtIndex(const int32 Index)
    {
        check(Index >= 0);
        PadToNum(Index + 1, false);
        SetBitNoCheck(Index, true);
    }
 
    void RemoveAtIndex(const int32 Index)
    {
        check(Index >= 0);
        if (Index < Num())
        {
            SetBitNoCheck(Index, false);
        }
        // else, it's already not present
    }
 
protected:
    void SetBitNoCheck(const int32 Index, const bool Value)
    {
        uint32& Word = GetData()[Index / NumBitsPerDWORD];
        const uint32 BitOffset = (Index % NumBitsPerDWORD);
        Word = (Word & ~(1 << BitOffset)) | (((uint32)Value) << BitOffset);
    }
};
 
// Ensure that FBitSetContainer does not add any new member variables compared to FConstBitSetContainer.
static_assert(sizeof(FBitSetContainer) == sizeof(FConstBitSetContainer), "FBitSetContainer as a functional extension of FConstBitSetContainer is not allowed add new member variables.");
 
} // namespace FStructTypeBitSet
 
struct FStructTracker
{
    using FBaseStructGetter = TFunction<UStruct*()>;
    using FTypeValidation = TFunction<bool(const UStruct*)>;
 
    UE_API explicit FStructTracker(const FBaseStructGetter& InBaseStructGetter);
    UE_API explicit FStructTracker(const UStruct* InBaseType, const FTypeValidation& InTypeVerification = FTypeValidation());
    UE_API ~FStructTracker();
 
    UE_NONCOPYABLE(FStructTracker);
 
    UE_API int32 FindStructTypeIndex(const UStruct& InStructType) const;
 
    UE_API int32 FindOrAddStructTypeIndex(const UStruct& InStructType);
 
    int32 Register(const UStruct& InStructType)
    {
        return RegisterImplementation(InStructType, /*bCheckPrevious=*/true);
    }
 
    const UStruct* GetStructType(const int32 StructTypeIndex) const
    {
        return StructTypesList.IsValidIndex(StructTypeIndex) ? StructTypesList[StructTypeIndex].Get() : nullptr;
    }
 
    UE_API const UStruct* GetBaseType() const;
 
    int32 Num() const { return StructTypeToIndexSet.Num(); }
 
    UE_API void Serialize(FArchive& Ar, FStructTypeBitSet::FBitSetContainer& StructTypesBitArray);
 
#if WITH_STRUCTUTILS_DEBUG
    FName DebugGetStructTypeName(const int32 StructTypeIndex) const
    {
        return DebugStructTypeNamesList.IsValidIndex(StructTypeIndex) ? DebugStructTypeNamesList[StructTypeIndex] : FName();
    }
 
    template<typename T>
    TConstArrayView<TWeakObjectPtr<const T>> DebugGetAllStructTypes() const 
    { 
        return MakeArrayView(reinterpret_cast<const TWeakObjectPtr<const T>*>(StructTypesList.GetData()), StructTypesList.Num());
    }
 
    void DebugResetStructTypeMappingInfo()
    {
        StructTypeToIndexSet.Reset();
        StructTypesList.Reset();
        DebugStructTypeNamesList.Reset();
    }
 
    [[nodiscard]] UE_API const UStruct* DebugFindTypeByPartialName(const FString& PartialName) const;
 
protected:
    mutable TArray<FName, TInlineAllocator<64>> DebugStructTypeNamesList;
#endif // WITH_STRUCTUTILS_DEBUG
 
protected:
    UE_API int32 RegisterImplementation(const UStruct& InStructType, const bool bCheckPrevious);
 
    TSet<uint32> StructTypeToIndexSet;
    TArray<TWeakObjectPtr<const UStruct>, TInlineAllocator<64>> StructTypesList;
    uint32 SerializationHash = 0;
    uint32 bIsSerializable : 1 = true;
    const FBaseStructGetter BaseStructGetter;
    const FTypeValidation TypeVerification;
 
private:
    mutable const UStruct* BaseType;
};
 
template<typename TImplementation, typename TBaseStruct, typename TStructType, typename TBitSetContainer, bool bTestInheritanceAtRuntime=WITH_STRUCTUTILS_DEBUG>
struct TTypeBitSetBase
{
    using FUStructType = TStructType;
    using FBaseStruct = TBaseStruct;
    using FContainer = TBitSetContainer;
 
    struct FIndexIterator
    {
        explicit FIndexIterator(const FStructTypeBitSet::FBitSetContainer& BitArray, const bool bInValueToCheck = true)
            : It(BitArray), bValueToCheck(bInValueToCheck)
        {
            if (It && It.GetValue() != bInValueToCheck)
            {
                // Will result in either setting It to the first bit with bInValueToCheck, or making bool(It) == false
                ++(*this);
            }
        }
 
        operator bool() const
        {
            return bool(It);
        }
 
        FIndexIterator& operator++() 
        { 
            while (++It)
            {
                if (It.GetValue() == bValueToCheck)
                {
                    break;
                }
            }
            return *this; 
        }
 
        int32 operator*() const
        {
            return It.GetIndex();
        }
 
    private:
        TBitArray<>::FConstIterator It;
        const bool bValueToCheck;
    };
 
    FIndexIterator GetIndexIterator(const bool bValueToCheck = true) const
    {
        return FIndexIterator(StructTypesBitArray, bValueToCheck);
    }
 
    TImplementation& GetImplementation()
    {
        return *reinterpret_cast<TImplementation*>(this);
    }
 
    const TImplementation& GetImplementation() const 
    {
        return *reinterpret_cast<const TImplementation*>(this);
    }
 
    inline static const UStruct* GetBaseUStruct()
    {
        if constexpr (bTestInheritanceAtRuntime)
        {
            static const UStruct* Instance = UE::StructUtils::GetAsUStruct<FBaseStruct>();
            return Instance;
        }
        else
        {
            return nullptr;
        }
    }
 
    void SetAll(const bool bValue = true)
    {
        StructTypesBitArray.SetAll(bValue, GetImplementation().GetStructTracker().Num());
    }
 
    void Add(const FUStructType& InStructType)
    {
        if constexpr (bTestInheritanceAtRuntime)
        {
            if (UNLIKELY(!ensureMsgf(InStructType.IsChildOf(GetBaseUStruct()),
                TEXT("Registering '%s' with FStructTracker while it doesn't derive from the expected struct type %s"),
                *InStructType.GetPathName(), *GetBaseUStruct()->GetName())))
            {
                return;
            }
        }
 
        const int32 StructTypeIndex = GetImplementation().GetStructTracker().FindOrAddStructTypeIndex(InStructType);
        StructTypesBitArray.AddAtIndex(StructTypeIndex);
    }
 
    void AddAtIndex(const int32 StructTypeIndex)
    {
        StructTypesBitArray.AddAtIndex(StructTypeIndex);
    }
 
    void Remove(const FUStructType& InStructType)
    {
        if constexpr (bTestInheritanceAtRuntime)
        {
            if (UNLIKELY(!ensureMsgf(InStructType.IsChildOf(GetBaseUStruct()),
                TEXT("Registering '%s' with FStructTracker while it doesn't derive from the expected struct type %s"),
                *InStructType.GetPathName(), *GetBaseUStruct()->GetName())))
            {
                return;
            }
        }
 
        const int32 StructTypeIndex = GetImplementation().GetStructTracker().FindOrAddStructTypeIndex(InStructType);
        StructTypesBitArray.RemoveAtIndex(StructTypeIndex);
    }
 
    void RemoveAtIndex(const int32 StructTypeIndex)
    {
        StructTypesBitArray.RemoveAtIndex(StructTypeIndex);
    }
 
    void Reset()
    {
        StructTypesBitArray.Reset();
    }
 
    bool Contains(const FUStructType& InStructType) const
    {
        if constexpr (bTestInheritanceAtRuntime)
        {
            if (UNLIKELY(!ensureMsgf(InStructType.IsChildOf(GetBaseUStruct()),
                TEXT("Registering '%s' with FStructTracker while it doesn't derive from the expected struct type %s"),
                *InStructType.GetPathName(), *GetBaseUStruct()->GetName())))
            {
                return false;
            }
        }
 
        const int32 StructTypeIndex = GetImplementation().GetStructTracker().FindStructTypeIndex(InStructType);
        return StructTypeIndex != INDEX_NONE && StructTypesBitArray.Contains(StructTypeIndex);
    }
 
    UE_FORCEINLINE_HINT TImplementation operator&(const TImplementation& Other) const
    {
        return TImplementation(TBitArray<>::BitwiseAND(StructTypesBitArray, Other.StructTypesBitArray, EBitwiseOperatorFlags::MinSize));
    }
 
    UE_FORCEINLINE_HINT TImplementation operator|(const TImplementation& Other) const
    {
        return TImplementation(TBitArray<>::BitwiseOR(StructTypesBitArray, Other.StructTypesBitArray, EBitwiseOperatorFlags::MaxSize));
    }
 
    UE_FORCEINLINE_HINT TImplementation GetOverlap(const TImplementation& Other) const
    {
        return GetImplementation() & Other;
    }
 
    UE_FORCEINLINE_HINT bool IsEquivalent(const TImplementation& Other) const
    {
        return StructTypesBitArray.CompareSetBits(Other.StructTypesBitArray, /*bMissingBitValue=*/false);
    }
 
    UE_FORCEINLINE_HINT bool HasAll(const TImplementation& Other) const
    {
        return StructTypesBitArray.HasAll(Other.StructTypesBitArray);
    }
 
    UE_FORCEINLINE_HINT bool HasAny(const TImplementation& Other) const
    {
        return StructTypesBitArray.HasAny(Other.StructTypesBitArray);
    }
 
    UE_FORCEINLINE_HINT bool HasNone(const TImplementation& Other) const
    {
        return !StructTypesBitArray.HasAny(Other.StructTypesBitArray);
    }
 
    bool IsEmpty() const 
    { 
        return StructTypesBitArray.IsEmpty();
    }
 
    UE_FORCEINLINE_HINT bool IsBitSet(const int32 BitIndex) const
    {
        return StructTypesBitArray.Contains(BitIndex);
    }
 
    UE_FORCEINLINE_HINT void operator+=(const TImplementation& Other)
    {
        StructTypesBitArray = TBitArray<>::BitwiseOR(StructTypesBitArray, Other.StructTypesBitArray, EBitwiseOperatorFlags::MaxSize);
    }
 
    UE_FORCEINLINE_HINT void operator-=(const TImplementation& Other)
    {
        StructTypesBitArray -= Other.StructTypesBitArray;
    }
 
    inline TImplementation operator+(const FUStructType& NewElement) const
    {
        TImplementation Result = GetImplementation();
        Result.Add(NewElement);
        return MoveTemp(Result);
    }
 
    inline TImplementation operator-(const FUStructType& NewElement) const
    {
        TImplementation Result = GetImplementation();
        Result.Remove(NewElement);
        return MoveTemp(Result);
    }
 
    int32 CountStoredTypes() const
    {
        return StructTypesBitArray.CountSetBits();
    }
 
    template<typename TOutStructType, typename Allocator>
    void ExportTypes(TArray<const TOutStructType*, Allocator>& OutTypes) const
    {
        TBitArray<>::FConstIterator It(StructTypesBitArray);
        while (It)
        {
            if (It.GetValue())
            {
                OutTypes.Add(Cast<TOutStructType>(GetImplementation().GetStructTracker().GetStructType(It.GetIndex())));
            }
            ++It;
        }
    }
 
#if WITH_STRUCTUTILS_DEBUG
    void DebugGetStringDesc(FOutputDevice& Ar) const
    {
        for (int32 Index = 0; Index < StructTypesBitArray.Num(); ++Index)
        {
            if (StructTypesBitArray[Index])
            {
                Ar.Logf(TEXT("%s, "), *GetImplementation().GetStructTracker().DebugGetStructTypeName(Index).ToString());
            }
        }
    }
 
    void DebugGetIndividualNames(TArray<FName>& OutFNames) const
    {
        for (int32 Index = 0; Index < StructTypesBitArray.Num(); ++Index)
        {
            if (StructTypesBitArray[Index])
            {
                OutFNames.Add(GetImplementation().GetStructTracker().DebugGetStructTypeName(Index));
            }
        }
    }
#endif // WITH_STRUCTUTILS_DEBUG
 
    SIZE_T GetAllocatedSize() const
    {
        return StructTypesBitArray.GetAllocatedSize();
    }
 
protected:
    TTypeBitSetBase() = default;
 
    TTypeBitSetBase(FContainer& InContainer)
        : StructTypesBitArray(InContainer)
    {
    }
 
#if WITH_STRUCTUTILS_DEBUG
    // For unit testing purposes only
    const TBitArray<>& DebugGetStructTypesBitArray() const { return StructTypesBitArray; }
    TBitArray<>& DebugGetMutableStructTypesBitArray() { return StructTypesBitArray; }
#endif // WITH_STRUCTUTILS_DEBUG
 
    FContainer StructTypesBitArray;
};
 
 
template<typename TBaseStruct, typename TStructTrackerWrapper, typename TUStructType = UScriptStruct>
struct TStructTypeBitSet : TTypeBitSetBase<TStructTypeBitSet<TBaseStruct, TStructTrackerWrapper, TUStructType>, TBaseStruct, TUStructType, FStructTypeBitSet::FBitSetContainer>
{
    using Super = TTypeBitSetBase<TStructTypeBitSet, TBaseStruct, TUStructType, FStructTypeBitSet::FBitSetContainer>;
    using FStructTrackerWrapper = TStructTrackerWrapper;
    using FUStructType = TUStructType;
    using FBaseStruct = TBaseStruct;
 
    friend Super;
    using Super::StructTypesBitArray;
    using Super::GetBaseUStruct;
    using Super::Add;
    using Super::Remove;
    using Super::Contains;
    using Super::operator+=;
    using Super::operator-=;
    using Super::operator+;
    using Super::operator-;
    using Super::ExportTypes;
 
    TStructTypeBitSet() = default;
 
    explicit TStructTypeBitSet(const FUStructType& StructType)
    {
        Add(StructType);
    }
 
    explicit TStructTypeBitSet(std::initializer_list<const FUStructType*> InitList)
    {
        for (const FUStructType* StructType : InitList)
        {
            if (StructType)
            {
                Add(*StructType);
            }
        }
    }
 
    explicit TStructTypeBitSet(TConstArrayView<const FUStructType*> InitList)
    {
        for (const FUStructType* StructType : InitList)
        {
            if (StructType)
            {
                Add(*StructType);
            }
        }
    }
 
    template<typename T = TBaseStruct, typename = typename TEnableIf<!TIsDerivedFrom<T, UObject>::IsDerived>::Type>
    explicit TStructTypeBitSet(TConstArrayView<FInstancedStruct> InitList)
    {
        for (const FInstancedStruct& StructInstance : InitList)
        {
            if (StructInstance.GetScriptStruct())
            {
                Add(*StructInstance.GetScriptStruct());
            }
        }
    }
 
private:
    TStructTypeBitSet(TBitArray<>&& Source)
    {
        StructTypesBitArray = Forward<TBitArray<>>(Source);
    }
 
    TStructTypeBitSet(const TBitArray<>& Source)
    {
        StructTypesBitArray = Source;
    }
 
    TStructTypeBitSet(const int32 BitToSet)
    {
        StructTypesBitArray.AddAtIndex(BitToSet);
    }
 
public:
 
    FStructTracker& GetStructTracker()
    {
        return TStructTrackerWrapper::StructTracker;
    }
 
    const FStructTracker& GetStructTracker() const
    {
        return TStructTrackerWrapper::StructTracker;
    }
 
    static int32 GetTypeIndex(const FUStructType& InStructType)
    {
#if WITH_STRUCTUTILS_DEBUG
        ensureMsgf(InStructType.IsChildOf(GetBaseUStruct())
            , TEXT("Creating index for '%s' while it doesn't derive from the expected struct type %s")
            , *InStructType.GetPathName(), *GetBaseUStruct()->GetName());
#endif // WITH_STRUCTUTILS_DEBUG
 
        return TStructTrackerWrapper::StructTracker.FindOrAddStructTypeIndex(InStructType);
    }
 
    template<typename T>
    static int32 GetTypeIndex()
    {
        static_assert(TIsDerivedFrom<T, TBaseStruct>::IsDerived, "Given struct type doesn't match the expected base struct type.");
        static const int32 TypeIndex = GetTypeIndex(*UE::StructUtils::GetAsUStruct<T>());
        return TypeIndex;
    }
    
    template<typename T>
    static const TStructTypeBitSet& GetTypeBitSet()
    {
        static_assert(TIsDerivedFrom<T, TBaseStruct>::IsDerived, "Given struct type doesn't match the expected base struct type.");
        static const TStructTypeBitSet TypeBitSet(GetTypeIndex<T>());
        return TypeBitSet;
    }
 
    static const FUStructType* GetTypeAtIndex(const int32 Index)
    {
        return Cast<const FUStructType>(TStructTrackerWrapper::StructTracker.GetStructType(Index));
    }
 
    template<typename T>
    inline void Add()
    {
        static_assert(TIsDerivedFrom<T, TBaseStruct>::IsDerived, "Given struct type doesn't match the expected base struct type.");
        const int32 StructTypeIndex = GetTypeIndex<T>();
        StructTypesBitArray.AddAtIndex(StructTypeIndex);
    }
 
    template<typename T>
    inline void Remove()
    {
        static_assert(TIsDerivedFrom<T, TBaseStruct>::IsDerived, "Given struct type doesn't match the expected base struct type.");
        const int32 StructTypeIndex = GetTypeIndex<T>();
        StructTypesBitArray.RemoveAtIndex(StructTypeIndex);
    }
 
    UE_FORCEINLINE_HINT void Remove(const TStructTypeBitSet& Other)
    {
        StructTypesBitArray -= Other.StructTypesBitArray;
    }
 
    template<typename T>
    inline bool Contains() const
    {
        static_assert(TIsDerivedFrom<T, TBaseStruct>::IsDerived, "Given struct type doesn't match the expected base struct type.");
        const int32 StructTypeIndex = GetTypeIndex<T>();
        return StructTypesBitArray.Contains(StructTypeIndex);
    }
 
    inline TStructTypeBitSet operator+(const TStructTypeBitSet& Other) const
    {
        TStructTypeBitSet Result;
        Result.StructTypesBitArray = TBitArray<>::BitwiseOR(StructTypesBitArray, Other.StructTypesBitArray, EBitwiseOperatorFlags::MaxSize);
        return MoveTemp(Result);
    }
 
    static int32 GetMaxNum() 
    {       
        return TStructTrackerWrapper::StructTracker.Num();
    }
 
    UE_FORCEINLINE_HINT bool operator==(const TStructTypeBitSet& Other) const
    {
        return Super::StructTypesBitArray == Other.StructTypesBitArray;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(const TStructTypeBitSet& Other) const
    {
        return !(*this == Other);
    }
 
    inline TStructTypeBitSet operator-(const TStructTypeBitSet& Other) const
    {
        TStructTypeBitSet Result = *this;
        Result -= Other;
        return MoveTemp(Result);
    }
 
    void ExportTypes(TFunctionRef<bool(const FUStructType*)> Callback) const
    {
        TBitArray<>::FConstIterator It(Super::StructTypesBitArray);
        bool bKeepGoing = true;
        while (bKeepGoing && It)
        {
            if (It.GetValue())
            {
                bKeepGoing = Callback(GetTypeAtIndex(It.GetIndex()));
            }
            ++It;
        }
    }
 
#if WITH_STRUCTUTILS_DEBUG
    using Super::DebugGetStringDesc;
    FString DebugGetStringDesc() const
    {
        FStringOutputDevice Ar;
        DebugGetStringDesc(Ar);
        return static_cast<FString>(Ar);
    }
#else
    FString DebugGetStringDesc() const
    {
        return TEXT("DEBUG INFO COMPILED OUT");
    }
#endif //WITH_STRUCTUTILS_DEBUG
 
#if WITH_STRUCTUTILS_DEBUG
    static FName DebugGetStructTypeName(const int32 StructTypeIndex)
    {
        return TStructTrackerWrapper::StructTracker.DebugGetStructTypeName(StructTypeIndex);
    }
 
    static TConstArrayView<TWeakObjectPtr<const TUStructType>> DebugGetAllStructTypes()
    {
        return TStructTrackerWrapper::StructTracker.template DebugGetAllStructTypes<TUStructType>();
    }
 
    static void DebugResetStructTypeMappingInfo()
    {
        TStructTrackerWrapper::StructTracker.DebugResetStructTypeMappingInfo();
    }
 
    [[nodiscard]] static const TUStructType* DebugFindTypeByPartialName(const FString& PartialName)
    {
        return reinterpret_cast<const TUStructType*>(TStructTrackerWrapper::StructTracker.DebugFindTypeByPartialName(PartialName));
    }
#endif // WITH_STRUCTUTILS_DEBUG
 
public:
    inline friend uint32 GetTypeHash(const TStructTypeBitSet& Instance)
    {
        const uint32 StoredTypeHash = PointerHash(GetBaseUStruct());
        const uint32 BitArrayHash = GetTypeHash(Instance.StructTypesBitArray);
        return HashCombine(StoredTypeHash, BitArrayHash);
    }
 
    void Serialize(FArchive& Ar)
    {
        TStructTrackerWrapper::StructTracker.Serialize(Ar, Super::StructTypesBitArray);
    }
 
    inline friend FArchive& operator<<(FArchive& Ar, TStructTypeBitSet& Instance)
    {
        Instance.Serialize(Ar);
        return Ar;
    }
};
 
#define _DECLARE_TYPEBITSET_IMPL(EXPORTED_API, ContainerTypeName, BaseType, BaseUStructType) struct ContainerTypeName##StructTrackerWrapper \
    { \
        using FBaseStructType = BaseType; \
        EXPORTED_API static FStructTracker StructTracker; \
    }; \
    using ContainerTypeName = TStructTypeBitSet<BaseType, ContainerTypeName##StructTrackerWrapper, BaseUStructType>; \
    static_assert(std::is_move_constructible_v<ContainerTypeName> && std::is_move_assignable_v<ContainerTypeName>)
 
#define DECLARE_STRUCTTYPEBITSET_EXPORTED(EXPORTED_API, ContainerTypeName, BaseStructType) _DECLARE_TYPEBITSET_IMPL(EXPORTED_API, ContainerTypeName, BaseStructType, UScriptStruct)
#define DECLARE_STRUCTTYPEBITSET(ContainerTypeName, BaseStructType) _DECLARE_TYPEBITSET_IMPL(, ContainerTypeName, BaseStructType, UScriptStruct)
#define DECLARE_CLASSTYPEBITSET_EXPORTED(EXPORTED_API, ContainerTypeName, BaseStructType) _DECLARE_TYPEBITSET_IMPL(EXPORTED_API, ContainerTypeName, BaseStructType, UClass)
#define DECLARE_CLASSTYPEBITSET(ContainerTypeName, BaseStructType) _DECLARE_TYPEBITSET_IMPL(, ContainerTypeName, BaseStructType, UClass)
 
#define DEFINE_TYPEBITSET(ContainerTypeName) \
    FStructTracker ContainerTypeName##StructTrackerWrapper::StructTracker([](){ return UE::StructUtils::GetAsUStruct<ContainerTypeName##StructTrackerWrapper::FBaseStructType>();});
 
#undef UE_API