IndirectArray.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "HAL/UnrealMemory.h"
#include "Templates/UnrealTypeTraits.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Array.h"
 
/*-----------------------------------------------------------------------------
    Indirect array.
    Same as a TArray, but stores pointers to the elements, to allow
    resizing the array index without relocating the actual elements.
-----------------------------------------------------------------------------*/
 
template<typename T,typename Allocator = FDefaultAllocator>
class TIndirectArray
{
public:
    typedef T                        ElementType;
    typedef TArray<void*, Allocator> InternalArrayType;
 
    [[nodiscard]] TIndirectArray() = default;
    [[nodiscard]] TIndirectArray(TIndirectArray&&) = default;
 
    [[nodiscard]] TIndirectArray(const TIndirectArray& Other)
    {
        for (auto& Item : Other)
        {
            Add(new T(Item));
        }
    }
 
    TIndirectArray& operator=(const TIndirectArray& Other)
    {
        if (&Other != this)
        {
            Empty(Other.Num());
            for (auto& Item : Other)
            {
                Add(new T(Item));
            }
        }
 
        return *this;
    }
    TIndirectArray &operator=(TIndirectArray && Other)
    {
        if (&Other != this)
        {
            Empty();
            Array = MoveTemp(Other.Array);
        }
 
        return *this;
    }
 
 
    ~TIndirectArray()
    {
        Empty();
    }
 
    [[nodiscard]] bool IsEmpty() const
    {
        return Array.IsEmpty();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT int32 Num() const
    {
        return Array.Num();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T** GetData()
    {
        return (T**)Array.GetData();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const T** GetData() const
    {
        return (const T**)Array.GetData();
    }
 
    [[nodiscard]] static constexpr uint32 GetTypeSize()
    {
        return sizeof(T*);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT T& operator[](int32 Index)
    {
        return *(T*)Array[Index];
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const T& operator[](int32 Index) const
    {
        return *(T*)Array[Index];
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT ElementType& Last(int32 IndexFromTheEnd = 0)
    {
        return *(T*)Array.Last(IndexFromTheEnd);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const ElementType& Last(int32 IndexFromTheEnd = 0) const
    {
        return *(T*)Array.Last(IndexFromTheEnd);
    }
 
    void Shrink()
    {
        Array.Shrink();
    }
 
    void Reset(int32 NewSize = 0)
    {
        DestructAndFreeItems();
        Array.Reset(NewSize);
    }
 
    void Serialize(FArchive& Ar, UObject* Owner)
    {
        CountBytes(Ar);
        if (Ar.IsLoading())
        {
            // Load array.
            int32 NewNum = 0;
            Ar << NewNum;
            Empty(NewNum);
            for (int32 Index = 0; Index < NewNum; Index++)
            {
                Add(new T);
            }
            for (int32 Index = 0; Index < NewNum; Index++)
            {
                (*this)[Index].Serialize(Ar, Owner, Index);
            }
        }
        else
        {
            // Save array.
            int32 Num = Array.Num();
            Ar << Num;
            for (int32 Index = 0; Index < Num; Index++)
            {
                (*this)[Index].Serialize(Ar, Owner, Index);
            }
        }
    }
 
    void CountBytes(FArchive& Ar) const
    {
        Array.CountBytes(Ar);
    }
 
    void RemoveAt(int32 Index, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<Allocator>())
    {
        check(Index >= 0);
        check(Index < Array.Num());
        T** Element = GetData() + Index;
        delete *Element;
        Array.RemoveAt(Index, AllowShrinking);
    }
 
    void RemoveAt(int32 Index, int32 Count, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<Allocator>())
    {
        check(Index >= 0);
        check(Index <= Array.Num());
        check(Index + Count <= Array.Num());
        T** Element = GetData() + Index;
        for (int32 ElementId = Count; ElementId; --ElementId)
        {
            delete *Element;
            ++Element;
        }
        Array.RemoveAt(Index, Count, AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveAt")
    UE_FORCEINLINE_HINT void RemoveAt(int32 Index, int32 Count, bool bAllowShrinking)
    {
        RemoveAt(Index, Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    void RemoveAtSwap(int32 Index, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<Allocator>())
    {
        check(Index >= 0);
        check(Index < Array.Num());
        T** Element = GetData() + Index;
        delete *Element;
        Array.RemoveAtSwap(Index, AllowShrinking);
    }
 
    void RemoveAtSwap(int32 Index, int32 Count, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<Allocator>())
    {
        check(Index >= 0);
        check(Index <= Array.Num());
        check(Index + Count <= Array.Num());
        T** Element = GetData() + Index;
        for (int32 ElementId = Count; ElementId; --ElementId)
        {
            delete *Element;
            ++Element;
        }
        Array.RemoveAtSwap(Index, Count, AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveAtSwap")
    UE_FORCEINLINE_HINT void RemoveAtSwap(int32 Index, int32 Count, bool bAllowShrinking)
    {
        RemoveAtSwap(Index, Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    void Swap(int32 FirstIndexToSwap, int32 SecondIndexToSwap)
    {
        Array.Swap(FirstIndexToSwap, SecondIndexToSwap);
    }
 
    void Empty(int32 Slack = 0)
    {
        DestructAndFreeItems();
        Array.Empty(Slack);
    }
 
    UE_FORCEINLINE_HINT int32 Add(T* Item)
    {
        return Array.Add(Item);
    }
 
    UE_FORCEINLINE_HINT void Insert(T* Item, int32 Index)
    {
        Array.Insert(Item, Index);
    }
 
    UE_FORCEINLINE_HINT void Reserve(int32 Number)
    {
        Array.Reserve(Number);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValidIndex(int32 Index) const
    {
        return Array.IsValidIndex(Index);
    }
 
    [[nodiscard]] SIZE_T GetAllocatedSize() const
    {
        return Array.Max() * sizeof(T*) + Array.Num() * sizeof(T);
    }
 
    // Iterators
    typedef TIndexedContainerIterator<      TIndirectArray,       ElementType, int32> TIterator;
    typedef TIndexedContainerIterator<const TIndirectArray, const ElementType, int32> TConstIterator;
 
    [[nodiscard]] TIterator CreateIterator()
    {
        return TIterator(*this);
    }
 
    [[nodiscard]] TConstIterator CreateConstIterator() const
    {
        return TConstIterator(*this);
    }
 
private:
 
    void DestructAndFreeItems()
    {
        T** Element = GetData();
        for (int32 Index = Array.Num(); Index; --Index)
        {
            delete *Element;
            ++Element;
        }
    }
 
public:
    [[nodiscard]] UE_FORCEINLINE_HINT TDereferencingIterator<      ElementType, typename InternalArrayType::RangedForIteratorType     > begin()       { return TDereferencingIterator<      ElementType, typename InternalArrayType::RangedForIteratorType     >(Array.begin()); }
    [[nodiscard]] UE_FORCEINLINE_HINT TDereferencingIterator<const ElementType, typename InternalArrayType::RangedForConstIteratorType> begin() const { return TDereferencingIterator<const ElementType, typename InternalArrayType::RangedForConstIteratorType>(Array.begin()); }
    [[nodiscard]] UE_FORCEINLINE_HINT TDereferencingIterator<      ElementType, typename InternalArrayType::RangedForIteratorType     > end  ()       { return TDereferencingIterator<      ElementType, typename InternalArrayType::RangedForIteratorType     >(Array.end()); }
    [[nodiscard]] UE_FORCEINLINE_HINT TDereferencingIterator<const ElementType, typename InternalArrayType::RangedForConstIteratorType> end  () const { return TDereferencingIterator<const ElementType, typename InternalArrayType::RangedForConstIteratorType>(Array.end()); }
 
private:
 
    InternalArrayType Array;
};
 
 
template<typename T,typename Allocator>
FArchive& operator<<(FArchive& Ar, TIndirectArray<T, Allocator>& A)
{
    A.CountBytes(Ar);
    if (Ar.IsLoading())
    {
        // Load array.
        int32 NewNum;
        Ar << NewNum;
        A.Empty(NewNum);
        for (int32 Index = 0; Index < NewNum; Index++)
        {
            T* NewElement = new T;
            Ar << *NewElement;
            A.Add(NewElement);
        }
    }
    else
    {
        // Save array.
        int32 Num = A.Num();
        Ar << Num;
        for (int32 Index = 0; Index < Num; Index++)
        {
            Ar << A[Index];
        }
    }
    return Ar;
}