TypeBitSetBuilder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "StructUtils/StructTypeBitSet.h"
#include "Templates/UnrealTypeTraits.h"
 
template <typename TBaseType>
struct TTypeBitSetTraits final
{
    template <typename TTestedType>
    static constexpr bool IsValidType = TIsDerivedFrom<TTestedType, TBaseType>::IsDerived;
};
 
template<typename TBaseStruct, typename TUStructType = UScriptStruct, bool bTestInheritanceAtRuntime=WITH_STRUCTUTILS_DEBUG, typename TContainer=FStructTypeBitSet::FBitSetContainer>
struct TTypeBitSetBuilder : TTypeBitSetBase<TTypeBitSetBuilder<TBaseStruct, TUStructType, bTestInheritanceAtRuntime>, TBaseStruct, TUStructType, TContainer&, bTestInheritanceAtRuntime>
{
    using Super = TTypeBitSetBase<TTypeBitSetBuilder, TBaseStruct, TUStructType, TContainer&, bTestInheritanceAtRuntime>;
    using FUStructType = TUStructType; 
    using FBaseStruct = TBaseStruct;   
    using FTraits = TTypeBitSetTraits<TBaseStruct>;
 
private:
    struct FBitSet : TContainer
    {
        inline bool operator==(const FBitSet& Other) const
        {
            return TContainer::CompareSetBits(Other, /*bMissingBitValue=*/false);
        }
    };
 
public:
    using FConstBitSet = const FBitSet;
 
    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;
 
    TTypeBitSetBuilder(FStructTracker& InStructTracker, FConstBitSet& Source)
        : Super(const_cast<FBitSet&>(Source))
        , StructTracker(InStructTracker)
    {
    }
 
private:    
    TTypeBitSetBuilder(FStructTracker& InStructTracker, FConstBitSet& Source, const int32 BitToSet)
        : Super(const_cast<FBitSet&>(Source))
        , StructTracker(InStructTracker)
    {
        StructTypesBitArray.AddAtIndex(BitToSet); 
    }
 
public:
    TTypeBitSetBuilder& operator=(const TTypeBitSetBuilder& Source)
    {
        ensureMsgf(&Source.StructTracker == &StructTracker, TEXT("Assignment is only allowed between two instances created with the same StructTracker."));
        StructTypesBitArray = Source.StructTypesBitArray; 
        return *this;
    }
 
    int32 GetTypeIndex(const TUStructType& InStructType) const
    {
        if constexpr (bTestInheritanceAtRuntime)
        {
            // Ensure the struct type derives from the base struct
            if (UNLIKELY(!ensureMsgf(InStructType.IsChildOf(GetBaseUStruct())
                , TEXT("Creating index for '%s' while it doesn't derive from the expected struct type %s")
                , *InStructType.GetPathName(), *GetBaseUStruct()->GetName())))
            {
                return INDEX_NONE;
            }
        }
 
        // Find or add the struct type index in the tracker
        return GetStructTracker().FindOrAddStructTypeIndex(InStructType);
    }
 
    static int32 GetTypeIndex(const FStructTracker& InStructTracker, const TUStructType& InStructType)
    {
        if constexpr (bTestInheritanceAtRuntime)
        {
            // Ensure the struct type derives from the base struct
            if (UNLIKELY(!ensureMsgf(InStructType.IsChildOf(GetBaseUStruct())
                , TEXT("Creating index for '%s' while it doesn't derive from the expected struct type %s")
                , *InStructType.GetPathName(), *GetBaseUStruct()->GetName())))
            {
                return INDEX_NONE;
            }
        }
 
        // Find or add the struct type index in the tracker
        return InStructTracker.FindOrAddStructTypeIndex(InStructType);
    }
 
    template<typename T>
    static int32 GetTypeIndex(FStructTracker& InStructTracker)
    {
        static_assert(FTraits::template IsValidType<T>, "Given struct is not a valid type for this TypeBitSetBuilder.");
        static const int32 TypeIndex = GetTypeIndex(InStructTracker, *UE::StructUtils::GetAsUStruct<T>());
        return TypeIndex;
    }
 
    template<typename T>
    int32 GetTypeIndex() const
    {
        static_assert(FTraits::template IsValidType<T>, "Given struct is not a valid type for this TypeBitSetBuilder.");
        static const int32 TypeIndex = GetTypeIndex(*UE::StructUtils::GetAsUStruct<T>());
        return TypeIndex;
    }
    
    template<typename T>
    static TTypeBitSetBuilder GetTypeBitSet(const TUStructType& InStructType)
    {
        static_assert(FTraits::template IsValidType<T>, "Given struct is not a valid type for this TypeBitSetBuilder.");
        return TTypeBitSetBuilder(GetTypeIndex<T>(InStructType));
    }
 
    const TUStructType* GetTypeAtIndex(const int32 Index)
    {
        return Cast<const TUStructType>(StructTracker.GetStructType(Index));
    }
    
    template<typename T>
    inline int32 Add()
    {
        static_assert(FTraits::template IsValidType<T>, "Given struct is not a valid type for this TypeBitSetBuilder.");
        const int32 StructTypeIndex = GetTypeIndex<T>();
        StructTypesBitArray.AddAtIndex(StructTypeIndex); 
        return StructTypeIndex;
    }
 
    template<typename T>
    inline int32 Remove()
    {
        static_assert(FTraits::template IsValidType<T>, "Given struct is not a valid type for this TypeBitSetBuilder.");
        const int32 StructTypeIndex = GetTypeIndex<T>();
        StructTypesBitArray.RemoveAtIndex(StructTypeIndex); 
        return StructTypeIndex;
    }
 
    inline void Remove(const TTypeBitSetBuilder& Other)
    {
        StructTypesBitArray -= Other.StructTypesBitArray;
    }
 
    template<typename T>
    inline bool Contains() const
    {
        static_assert(FTraits::template IsValidType<T>, "Given struct is not a valid type for this TypeBitSetBuilder.");
        const int32 StructTypeIndex = GetTypeIndex<T>();
        return StructTypesBitArray.Contains(StructTypeIndex);
    }
 
    inline TTypeBitSetBuilder operator-(const TTypeBitSetBuilder& Other) const
    {
        TTypeBitSetBuilder Result = *this;
        Result -= Other;
        return MoveTemp(Result);
    }
 
    inline TTypeBitSetBuilder operator+(const TTypeBitSetBuilder& Other) const
    {
        TTypeBitSetBuilder Result(StructTracker);
        Result.StructTypesBitArray = TBitArray<>::BitwiseOR(StructTypesBitArray, Other.StructTypesBitArray, EBitwiseOperatorFlags::MaxSize);
        return MoveTemp(Result);
    }
 
    inline TTypeBitSetBuilder operator&(const TTypeBitSetBuilder& Other) const
    {
        return TTypeBitSetBuilder(StructTracker, TBitArray<>::BitwiseAND(StructTypesBitArray, Other.StructTypesBitArray, EBitwiseOperatorFlags::MinSize));
    }
 
    inline TTypeBitSetBuilder operator|(const TTypeBitSetBuilder& Other) const
    {
        return TTypeBitSetBuilder(StructTracker, TBitArray<>::BitwiseOR(StructTypesBitArray, Other.StructTypesBitArray, EBitwiseOperatorFlags::MaxSize));
    }
 
    inline TTypeBitSetBuilder GetOverlap(const TTypeBitSetBuilder& Other) const
    {
        return *this & Other;
    }
 
    inline bool IsEquivalent(const TTypeBitSetBuilder& Other) const
    {
        return StructTypesBitArray.CompareSetBits(Other.StructTypesBitArray, /*bMissingBitValue=*/false);
    }
 
    inline bool HasAll(const TTypeBitSetBuilder& Other) const
    {
        return StructTypesBitArray.HasAll(Other.StructTypesBitArray);
    }
 
    inline bool HasAny(const TTypeBitSetBuilder& Other) const
    {
        return StructTypesBitArray.HasAny(Other.StructTypesBitArray);
    }
 
    inline bool HasNone(const TTypeBitSetBuilder& Other) const
    {
        return !StructTypesBitArray.HasAny(Other.StructTypesBitArray);
    }
 
    bool IsEmpty() const 
    { 
        return StructTypesBitArray.IsEmpty();
    }
 
    inline bool IsBitSet(const int32 BitIndex) const
    {
        return StructTypesBitArray.Contains(BitIndex);
    }
 
    int32 CountStoredTypes() const
    {
        return StructTypesBitArray.CountSetBits();
    }
 
    int32 GetMaxNum() const
    {       
        return StructTracker.Num();
    }
 
    static int32 GetMaxNum(const FStructTracker& StructTracker)
    {       
        return StructTracker.Num();
    }
 
    inline bool operator==(const TTypeBitSetBuilder& Other) const
    {
        return StructTypesBitArray.CompareSetBits(Other.StructTypesBitArray, /*bMissingBitValue=*/false);
    }
 
    inline bool operator!=(const TTypeBitSetBuilder& Other) const
    {
        return !(*this == Other);
    }
 
    operator FConstBitSet() const
    {
        return static_cast<FConstBitSet&>(StructTypesBitArray);
    }
 
    template<typename TOutStructType, typename Allocator>
    void ExportTypes(TArray<const TOutStructType*, Allocator>& OutTypes) const
    {
        TBitArray<>::FConstIterator It(StructTypesBitArray);
        while (It)
        {
            if (It.GetValue())
            {
                // Get the struct type from the tracker and add to the output array
                OutTypes.Add(Cast<TOutStructType>(StructTracker.GetStructType(It.GetIndex())));
            }
            ++It;
        }
    }
 
    void ExportTypes(TFunctionRef<bool(const TUStructType*)> Callback) const
    {
        TBitArray<>::FConstIterator It(StructTypesBitArray);
        bool bKeepGoing = true;
        while (bKeepGoing && It)
        {
            if (It.GetValue())
            {
                bKeepGoing = Callback(GetTypeAtIndex(It.GetIndex()));
            }
            ++It;
        }
    }
 
    SIZE_T GetAllocatedSize() const
    {
        return StructTypesBitArray.GetAllocatedSize();
    }
 
    FString DebugGetStringDesc() const
    {
    #if WITH_STRUCTUTILS_DEBUG
        FStringOutputDevice Ar;
        DebugGetStringDesc(Ar);
        return static_cast<FString>(Ar);
    #else
        return TEXT("DEBUG INFO COMPILED OUT");
    #endif //WITH_STRUCTUTILS_DEBUG
    }
 
#if WITH_STRUCTUTILS_DEBUG
    void DebugGetStringDesc(FOutputDevice& Ar) const
    {
        for (int32 Index = 0; Index < StructTypesBitArray.Num(); ++Index)
        {
            if (StructTypesBitArray[Index])
            {
                // Get the name of the struct type and log it
                Ar.Logf(TEXT("%s, "), *StructTracker.DebugGetStructTypeName(Index).ToString());
            }
        }
    }
 
    void DebugGetIndividualNames(TArray<FName>& OutFNames) const
    {
        for (int32 Index = 0; Index < StructTypesBitArray.Num(); ++Index)
        {
            if (StructTypesBitArray[Index])
            {
                OutFNames.Add(StructTracker.DebugGetStructTypeName(Index));
            }
        }
    }
 
    FName DebugGetStructTypeName(const int32 StructTypeIndex) const
    {
        return StructTracker.DebugGetStructTypeName(StructTypeIndex);
    }
 
    TConstArrayView<TWeakObjectPtr<const TUStructType>> DebugGetAllStructTypes() const
    {
        return StructTracker.DebugGetAllStructTypes<TUStructType>();
    }
 
    static FName DebugGetStructTypeName(const FStructTracker& StructTracker, const int32 StructTypeIndex)
    {
        return StructTracker.DebugGetStructTypeName(StructTypeIndex);
    }
 
    static TConstArrayView<TWeakObjectPtr<const TUStructType>> DebugGetAllStructTypes(const FStructTracker& StructTracker)
    {
        return StructTracker.DebugGetAllStructTypes<TUStructType>();
    }
 
protected:
    const TBitArray<>& DebugGetStructTypesBitArray() const 
    { 
        return StructTypesBitArray; 
    }
 
    TBitArray<>& DebugGetMutableStructTypesBitArray() 
    { 
        return StructTypesBitArray; 
    }
#endif // WITH_STRUCTUTILS_DEBUG
 
protected:
    FStructTracker& GetStructTracker() const
    {
        return StructTracker;
    }
 
private:
    FStructTracker& StructTracker; 
};