Array.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 "Misc/IntrusiveUnsetOptionalState.h"
#include "Misc/ReverseIterate.h"
#include "HAL/UnrealMemory.h"
#include "Templates/UnrealTypeTraits.h"
#include "Templates/UnrealTemplate.h"
#include "Containers/AllowShrinking.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/ContainerElementTypeCompatibility.h"
#include "Serialization/Archive.h"
#include "Serialization/MemoryImageWriter.h"
 
#include "Algo/Heapify.h"
#include "Algo/HeapSort.h"
#include "Algo/IsHeap.h"
#include "Algo/Impl/BinaryHeap.h"
#include "Algo/StableSort.h"
#include "Concepts/GetTypeHashable.h"
#include "Templates/IdentityFunctor.h"
#include "Templates/Invoke.h"
#include "Templates/Less.h"
#include "Templates/LosesQualifiersFromTo.h"
#include "Templates/Requires.h"
#include "Templates/Sorting.h"
#include "Templates/AlignmentTemplates.h"
#include "Traits/ElementType.h"
#include "Traits/IsTriviallyRelocatable.h"
 
#include <limits>
#include <type_traits>
 
#if UE_BUILD_SHIPPING || UE_BUILD_TEST
    #define TARRAY_RANGED_FOR_CHECKS 0
#else
    #define TARRAY_RANGED_FOR_CHECKS 1
#endif
 
template <typename T>
struct TCanBulkSerialize
{
    enum { Value = std::is_arithmetic_v<T> };
};
 
// Forward declarations
 
template <typename T, typename AllocatorType> inline void* operator new(size_t Size, TArray<T, AllocatorType>& Array);
template <typename T, typename AllocatorType> inline void* operator new(size_t Size, TArray<T, AllocatorType>& Array, typename TArray<T, AllocatorType>::SizeType Index);
 
template <typename ContainerType, typename ElementType, typename SizeType>
class TIndexedContainerIterator
{
public:
    UE_NODEBUG [[nodiscard]] TIndexedContainerIterator(ContainerType& InContainer, SizeType StartIndex = 0)
        : Container(InContainer)
        , Index    (StartIndex)
    {
    }
 
    UE_NODEBUG TIndexedContainerIterator& operator++()
    {
        ++Index;
        return *this;
    }
    UE_NODEBUG TIndexedContainerIterator operator++(int)
    {
        TIndexedContainerIterator Tmp(*this);
        ++Index;
        return Tmp;
    }
 
    UE_NODEBUG TIndexedContainerIterator& operator--()
    {
        --Index;
        return *this;
    }
    UE_NODEBUG TIndexedContainerIterator operator--(int)
    {
        TIndexedContainerIterator Tmp(*this);
        --Index;
        return Tmp;
    }
 
    UE_NODEBUG TIndexedContainerIterator& operator+=(SizeType Offset)
    {
        Index += Offset;
        return *this;
    }
 
    UE_NODEBUG [[nodiscard]] TIndexedContainerIterator operator+(SizeType Offset) const
    {
        TIndexedContainerIterator Tmp(*this);
        return Tmp += Offset;
    }
 
    UE_NODEBUG TIndexedContainerIterator& operator-=(SizeType Offset)
    {
        return *this += -Offset;
    }
 
    UE_NODEBUG [[nodiscard]] TIndexedContainerIterator operator-(SizeType Offset) const
    {
        TIndexedContainerIterator Tmp(*this);
        return Tmp -= Offset;
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& operator* () const
    {
        return Container[ Index ];
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType* operator->() const
    {
        return &Container[ Index ];
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return Container.IsValidIndex(Index);
    }
 
    UE_NODEBUG [[nodiscard]] SizeType GetIndex() const
    {
        return Index;
    }
 
    UE_NODEBUG void Reset()
    {
        Index = 0;
    }
 
    UE_NODEBUG void SetToEnd()
    {
        Index = Container.Num();
    }
 
    UE_NODEBUG void RemoveCurrent()
    {
        Container.RemoveAt(Index);
        Index--;
    }
 
    UE_NODEBUG void RemoveCurrentSwap()
    {
        Container.RemoveAtSwap(Index);
        Index--;
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT bool operator==(const TIndexedContainerIterator& Rhs) const
    {
        return &Container == &Rhs.Container && Index == Rhs.Index;
    }
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TIndexedContainerIterator& Rhs) const
    {
        return &Container != &Rhs.Container || Index != Rhs.Index;
    }
#endif
 
private:
    ContainerType& Container;
    SizeType      Index;
};
 
 
template <typename ContainerType, typename ElementType, typename SizeType>
UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT TIndexedContainerIterator<ContainerType, ElementType, SizeType> operator+(SizeType Offset, TIndexedContainerIterator<ContainerType, ElementType, SizeType> RHS)
{
    return RHS + Offset;
}
 
 
#if TARRAY_RANGED_FOR_CHECKS
    template <typename ElementType, typename SizeType, bool bReverse = false>
    struct TCheckedPointerIterator
    {
        // This iterator type only supports the minimal functionality needed to support
        // C++ ranged-for syntax.  For example, it does not provide post-increment ++ or any operation you wouldn't expect from a raw pointer.
        //
        // We do add an operator-- to help FString implementation
 
        UE_NODEBUG [[nodiscard]] explicit TCheckedPointerIterator(const SizeType& InNum, ElementType* InPtr)
            : Ptr       (InPtr)
            , CurrentNum(InNum)
            , InitialNum(InNum)
        {
        }
 
        UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType* operator->() const
        {
            if constexpr (bReverse)
            {
                return Ptr - 1;
            }
            else
            {
                return Ptr;
            }
        }
 
        UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& operator*() const
        {
            if constexpr (bReverse)
            {
                return *(Ptr - 1);
            }
            else
            {
                return *Ptr;
            }
        }
 
        UE_NODEBUG UE_FORCEINLINE_HINT TCheckedPointerIterator& operator++()
        {
            if constexpr (bReverse)
            {
                --Ptr;
            }
            else
            {
                ++Ptr;
            }
            return *this;
        }
 
        UE_NODEBUG UE_FORCEINLINE_HINT TCheckedPointerIterator& operator--()
        {
            if constexpr (bReverse)
            {
                ++Ptr;
            }
            else
            {
                --Ptr;
            }
            return *this;
        }
 
        UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TCheckedPointerIterator& Rhs) const
        {
            // We only need to do the check in this operator, because no other operator will be
            // called until after this one returns.
            //
            // Also, we should only need to check one side of this comparison - if the other iterator isn't
            // even from the same array then the compiler has generated bad code.
            ensureMsgf(CurrentNum == InitialNum, TEXT("Array has changed during ranged-for iteration!"));
            return Ptr != Rhs.Ptr;
        }
 
        UE_NODEBUG [[nodiscard]] FORCEINLINE bool operator==(const TCheckedPointerIterator& Rhs) const
        {
            return !(*this != Rhs);
        }
 
 
    private:
        ElementType*    Ptr;
        const SizeType& CurrentNum;
        SizeType        InitialNum;
    };
#endif
 
 
template <typename ElementType, typename IteratorType>
struct TDereferencingIterator
{
    UE_NODEBUG [[nodiscard]] explicit TDereferencingIterator(IteratorType InIter)
        : Iter(InIter)
    {
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& operator*() const
    {
        return *(ElementType*)*Iter;
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT TDereferencingIterator& operator++()
    {
        ++Iter;
        return *this;
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT bool operator!=(const TDereferencingIterator& Rhs) const
    {
        return Iter != Rhs.Iter;
    }
 
private:
    IteratorType Iter;
};
 
namespace UE::Core::Private
{
    // Simply forwards to an unqualified GetData(), but can be called from within a container or view
    // where GetData() is already a member and so hides any others.
    template <typename T>
    [[nodiscard]] UE_FORCEINLINE_HINT decltype(auto) GetDataHelper(T&& Arg)
    {
        return GetData(Forward<T>(Arg));
    }
 
    template <typename FromArrayType, typename ToArrayType>
    UE_NODEBUG [[nodiscard]] constexpr bool CanMoveTArrayPointersBetweenArrayTypes()
    {
        using FromAllocatorType          = typename FromArrayType::AllocatorType;
        using ToAllocatorType            = typename ToArrayType::AllocatorType;
        using FromElementType            = typename FromArrayType::ElementType;
        using ToElementType              = typename ToArrayType::ElementType;
        using UnqualifiedFromElementType = std::remove_cv_t<FromElementType>;
        using UnqualifiedToElementType   = std::remove_cv_t<ToElementType>;
 
        // Allocators must be equal or move-compatible...
        if constexpr (std::is_same_v<FromAllocatorType, ToAllocatorType> || TCanMoveBetweenAllocators<FromAllocatorType, ToAllocatorType>::Value)
        {
            return
                !TLosesQualifiersFromTo_V<FromElementType, ToElementType> &&
                (
                    std::is_same_v         <const ToElementType, const FromElementType> ||               // The element type of the container must be the same, or...
                    TIsBitwiseConstructible<UnqualifiedToElementType, UnqualifiedFromElementType>::Value // ... the element type of the source container must be bitwise constructible from the element type in the destination container
                );
        }
        else
        {
            return false;
        }
    }
 
    // Assume elements are compatible with themselves - avoids problems with generated copy
    // constructors of arrays of forwarded types, e.g.:
    //
    // struct FThing;
    //
    // struct FOuter
    // {
    //     TArray<FThing> Arr; // this will cause errors without this workaround
    // };
    template <typename DestType, typename SourceType>
    constexpr bool TArrayElementsAreCompatible_V = std::disjunction_v<std::is_same<DestType, std::decay_t<SourceType>>, std::is_constructible<DestType, SourceType>>;
 
    template <typename ElementType, typename AllocatorType>
    UE_NODEBUG static char (&ResolveIsTArrayPtr(const volatile TArray<ElementType, AllocatorType>*))[2];
    UE_NODEBUG static char(&ResolveIsTArrayPtr(...))[1];
 
    template <typename T>
    constexpr bool TIsTArrayOrDerivedFromTArray_V = sizeof(ResolveIsTArrayPtr((T*)nullptr)) == 2;
 
    [[noreturn]] CORE_API void OnInvalidArrayNum(unsigned long long NewNum);
 
    // A hacky way to get the SizeType, since it's defined in the
    // (outer) allocator type, not the (inner) allocator instance type
    template <typename AllocatorInstanceType>
    using TAllocatorSizeType_T = decltype(std::declval<AllocatorInstanceType&>().GetInitialCapacity());
 
    // Flags are passed as a uint32 to minimize PDB impact of these generated symbols.
    //
    // 1 == TAllocatorTraits<>::SupportsElementAlignment
    // 2 == TAllocatorTraits<>::SupportsSlackTracking
    //
    // When C++20 is guaranteed, concept checks can be used instead.
    template <typename AllocatorType>
    UE_NODEBUG [[nodiscard]] constexpr uint32 GetAllocatorFlags()
    {
        uint32 Result = 0;
        if constexpr (TAllocatorTraits<AllocatorType>::SupportsElementAlignment)
        {
            Result |= 1;
        }
        if constexpr (TAllocatorTraits<AllocatorType>::SupportsSlackTracking)
        {
            Result |= 2;
        }
        return Result;
    }
 
 
    // Called only when we KNOW we are going to do a realloc increasing by 1.
    // In this case, we know that max == num and can simplify things in a very
    // hot location in the code.
    // This returns the old ArrayMax in order to save a register clobber/reload.
    template <uint32 Flags, typename AllocatorInstanceType>
    UE_FORCEINLINE_HINT TAllocatorSizeType_T<AllocatorInstanceType> ReallocGrow1_DoAlloc_Impl(
        uint32                                       ElementSize,
        uint32                                       ElementAlignment,
        AllocatorInstanceType&                       AllocatorInstance,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayMax
    )
    {
        using SizeType  = TAllocatorSizeType_T<AllocatorInstanceType>;
        using USizeType = std::make_unsigned_t<SizeType>;
 
        const USizeType UOldMax = (USizeType)ArrayMax;
        const USizeType UNewNum = UOldMax + 1U;
        const SizeType  OldMax  = (SizeType)UOldMax;
        const SizeType  NewNum  = (SizeType)UNewNum;
 
        // This should only happen when we've underflowed or overflowed SizeType
        if (NewNum < OldMax)
        {
            OnInvalidArrayNum((unsigned long long)UNewNum);
        }
 
        SizeType NewMax;
        if constexpr (!!(Flags & 1)) // TAllocatorTraits<AllocatorType>::SupportsElementAlignment
        {
            NewMax = AllocatorInstance.CalculateSlackGrow(NewNum, OldMax, ElementSize, ElementAlignment);
            AllocatorInstance.ResizeAllocation(UOldMax, NewMax, ElementSize, ElementAlignment);
        }
        else
        {
            NewMax = AllocatorInstance.CalculateSlackGrow(NewNum, OldMax, ElementSize);
            AllocatorInstance.ResizeAllocation(UOldMax, NewMax, ElementSize);
        }
        ArrayMax = NewMax;
        #if UE_ENABLE_ARRAY_SLACK_TRACKING
        if constexpr (!!(Flags & 2)) // TAllocatorTraits<AllocatorType>::SupportsSlackTracking
        {
            AllocatorInstance.SlackTrackerLogNum(NewNum);
        }
        #endif
 
        return OldMax;
    }
 
    // Version for small sizes/alignments. This allows the parameter setup to be a single instruction
    // note the uint16 limitation allows for a single instruction setup on arm.
    template <uint32 Flags, typename AllocatorInstanceType>
    FORCENOINLINE TAllocatorSizeType_T<AllocatorInstanceType> ReallocGrow1_DoAlloc_Tiny(
        uint16                                       ElementSizeAndAlignment,
        AllocatorInstanceType&                       AllocatorInstance,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayMax
    )
    {
        return ReallocGrow1_DoAlloc_Impl<Flags, AllocatorInstanceType>(ElementSizeAndAlignment & 0xff, ElementSizeAndAlignment >> 8, AllocatorInstance, ArrayMax);
    }
 
    template <uint32 Flags, typename AllocatorInstanceType>
    FORCENOINLINE TAllocatorSizeType_T<AllocatorInstanceType> ReallocGrow1_DoAlloc(
        uint32                                       ElementSize,
        uint32                                       ElementAlignment,
        AllocatorInstanceType&                       AllocatorInstance,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayMax
    )
    {
        return ReallocGrow1_DoAlloc_Impl<Flags, AllocatorInstanceType>(ElementSize, ElementAlignment, AllocatorInstance, ArrayMax);
    }
 
    // This should be used for repeated growing operations when reallocations are to be amortized over multiple inserts.
    template <uint32 Flags, typename AllocatorInstanceType>
    FORCENOINLINE TAllocatorSizeType_T<AllocatorInstanceType> ReallocGrow(
        uint32                                       ElementSize,
        uint32                                       ElementAlignment,
        TAllocatorSizeType_T<AllocatorInstanceType>  Count,
        AllocatorInstanceType&                       AllocatorInstance,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayNum,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayMax
    )
    {
        using SizeType  = TAllocatorSizeType_T<AllocatorInstanceType>;
        using USizeType = std::make_unsigned_t<SizeType>;
 
        const USizeType UCount  = (USizeType)Count;
        const USizeType UOldNum = (USizeType)ArrayNum;
        const USizeType UOldMax = (USizeType)ArrayMax;
        const USizeType UNewNum = UOldNum + UCount;
        const SizeType  OldNum  = (SizeType)UOldNum;
        const SizeType  OldMax  = (SizeType)UOldMax;
        const SizeType  NewNum  = (SizeType)UNewNum;
 
        checkSlow((OldNum >= 0) & (OldMax >= OldNum) & (Count >= 0)); // & for one branch
 
        ArrayNum = NewNum;
 
#if DO_GUARD_SLOW
        if (UNewNum > UOldMax)
#else
        // SECURITY - This check will guard against negative counts too, in case the checkSlow above is compiled out.
        // However, it results in slightly worse code generation.
        if (UCount > UOldMax - UOldNum)
#endif
        {
            // This should only happen when we've underflowed or overflowed SizeType
            if (NewNum < OldNum)
            {
                OnInvalidArrayNum((unsigned long long)UNewNum);
            }
            SizeType NewMax;
            if constexpr (!!(Flags & 1)) // TAllocatorTraits<AllocatorType>::SupportsElementAlignment
            {
                NewMax = AllocatorInstance.CalculateSlackGrow(NewNum, OldMax, ElementSize, ElementAlignment);
                AllocatorInstance.ResizeAllocation(UOldNum, NewMax, ElementSize, ElementAlignment);
            }
            else
            {
                NewMax = AllocatorInstance.CalculateSlackGrow(NewNum, OldMax, ElementSize);
                AllocatorInstance.ResizeAllocation(UOldNum, NewMax, ElementSize);
            }
            ArrayMax = NewMax;
#if UE_ENABLE_ARRAY_SLACK_TRACKING
            if constexpr (!!(Flags & 2)) // TAllocatorTraits<AllocatorType>::SupportsSlackTracking
            {
                AllocatorInstance.SlackTrackerLogNum(NewNum);
            }
#endif
        }
 
        return OldNum;
    }
 
    // This should be used for repeated shrinking operations when reallocations are to be amortized over multiple removals.
    template <uint32 Flags, typename AllocatorInstanceType>
    FORCENOINLINE void ReallocShrink(
        uint32                                       ElementSize,
        uint32                                       ElementAlignment,
        AllocatorInstanceType&                       AllocatorInstance,
        TAllocatorSizeType_T<AllocatorInstanceType>  ArrayNum,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayMax
    )
    {
        using SizeType  = TAllocatorSizeType_T<AllocatorInstanceType>;
 
        SizeType OldArrayMax = ArrayMax;
 
        if constexpr (!!(Flags & 1)) // TAllocatorTraits<AllocatorType>::SupportsElementAlignment
        {
            SizeType NewArrayMax = AllocatorInstance.CalculateSlackShrink(ArrayNum, OldArrayMax, ElementSize, ElementAlignment);
            if (NewArrayMax != OldArrayMax)
            {
                ArrayMax = NewArrayMax;
                AllocatorInstance.ResizeAllocation(ArrayNum, NewArrayMax, ElementSize, ElementAlignment);
            }
        }
        else
        {
            SizeType NewArrayMax = AllocatorInstance.CalculateSlackShrink(ArrayNum, OldArrayMax, ElementSize);
            if (NewArrayMax != OldArrayMax)
            {
                ArrayMax = NewArrayMax;
                AllocatorInstance.ResizeAllocation(ArrayNum, NewArrayMax, ElementSize);
            }
        }
    }
 
    // This should be used for setting an allocation to a specific size.
    // Precondition: NewMax >= ArrayNum.
    template <uint32 Flags, typename AllocatorInstanceType>
    FORCENOINLINE void ReallocTo(
        uint32                                       ElementSize,
        uint32                                       ElementAlignment,
        TAllocatorSizeType_T<AllocatorInstanceType>  NewMax,
        AllocatorInstanceType&                       AllocatorInstance,
        TAllocatorSizeType_T<AllocatorInstanceType>  ArrayNum,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayMax
    )
    {
        if constexpr (!!(Flags & 1)) // TAllocatorTraits<AllocatorType>::SupportsElementAlignment
        {
            if (NewMax)
            {
                NewMax = AllocatorInstance.CalculateSlackReserve(NewMax, ElementSize, ElementAlignment);
            }
            if (NewMax != ArrayMax)
            {
                ArrayMax = NewMax;
                AllocatorInstance.ResizeAllocation(ArrayNum, NewMax, ElementSize, ElementAlignment);
            }
        }
        else
        {
            if (NewMax)
            {
                NewMax = AllocatorInstance.CalculateSlackReserve(NewMax, ElementSize);
            }
            if (NewMax != ArrayMax)
            {
                ArrayMax = NewMax;
                AllocatorInstance.ResizeAllocation(ArrayNum, NewMax, ElementSize);
            }
        }
    }
 
    template <uint32 Flags, typename AllocatorInstanceType>
    FORCENOINLINE void ReallocForCopy(
        uint32                                       ElementSize,
        uint32                                       ElementAlignment,
        TAllocatorSizeType_T<AllocatorInstanceType>  NewMax,
        TAllocatorSizeType_T<AllocatorInstanceType>  PrevMax,
        AllocatorInstanceType&                       AllocatorInstance,
        TAllocatorSizeType_T<AllocatorInstanceType>  ArrayNum,
        TAllocatorSizeType_T<AllocatorInstanceType>& ArrayMax
    )
    {
        if constexpr (!!(Flags & 1)) // TAllocatorTraits<AllocatorType>::SupportsElementAlignment
        {
            if (NewMax)
            {
                NewMax = AllocatorInstance.CalculateSlackReserve(NewMax, ElementSize, ElementAlignment);
            }
            if (NewMax > PrevMax)
            {
                AllocatorInstance.ResizeAllocation(0, NewMax, ElementSize, ElementAlignment);
            }
            else
            {
                NewMax = PrevMax;
            }
        }
        else
        {
            if (NewMax)
            {
                NewMax = AllocatorInstance.CalculateSlackReserve(NewMax, ElementSize);
            }
            if (NewMax > PrevMax)
            {
                AllocatorInstance.ResizeAllocation(0, NewMax, ElementSize);
            }
            else
            {
                NewMax = PrevMax;
            }
        }
        ArrayMax = NewMax;
    }
}
 
 
template<typename InElementType, typename InAllocatorType>
class TArray
{
    template <typename OtherInElementType, typename OtherAllocator>
    friend class TArray;
 
public:
    using SizeType      = typename InAllocatorType::SizeType ;
    using ElementType   = InElementType;
    using AllocatorType = InAllocatorType;
 
private:
    using USizeType = typename std::make_unsigned_t<SizeType>;
 
public:
    using ElementAllocatorType = std::conditional_t<
        AllocatorType::NeedsElementType,
        typename AllocatorType::template ForElementType<ElementType>,
        typename AllocatorType::ForAnyElementType
    >;
 
    static_assert(std::is_signed_v<SizeType>, "TArray only supports signed index types");
 
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr TArray()
        : ArrayNum(0)
        , ArrayMax(AllocatorInstance.GetInitialCapacity())
    {
    }
 
    [[nodiscard]] explicit consteval TArray(EConstEval)
        : AllocatorInstance(ConstEval)
        , ArrayNum(0)
        , ArrayMax(AllocatorInstance.GetInitialCapacity())
    {
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TArray(const ElementType* Ptr, SizeType Count)
    {
        if (Count < 0)
        {
            // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
            UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)Count);
        }
 
        check(Ptr != nullptr || Count == 0);
 
        CopyToEmpty(Ptr, Count, 0);
    }
 
    template <typename OtherElementType, typename OtherSizeType>
    [[nodiscard]] explicit TArray(const TArrayView<OtherElementType, OtherSizeType>& Other);
 
    [[nodiscard]] TArray(std::initializer_list<InElementType> InitList)
    {
        // This is not strictly legal, as std::initializer_list's iterators are not guaranteed to be pointers, but
        // this appears to be the case on all of our implementations.  Also, if it's not true on a new implementation,
        // it will fail to compile rather than behave badly.
        CopyToEmpty(InitList.begin(), (SizeType)InitList.size(), 0);
    }
 
    template <
        typename OtherElementType,
        typename OtherAllocator
        UE_REQUIRES(UE::Core::Private::TArrayElementsAreCompatible_V<ElementType, const OtherElementType&>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT explicit TArray(const TArray<OtherElementType, OtherAllocator>& Other)
    {
        CopyToEmpty(Other.GetData(), Other.Num(), 0);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TArray(const TArray& Other)
    {
        CopyToEmpty(Other.GetData(), Other.Num(), 0);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TArray(const TArray& Other, SizeType ExtraSlack)
    {
        CopyToEmptyWithSlack(Other.GetData(), Other.Num(), 0, ExtraSlack);
    }
 
    TArray& operator=(std::initializer_list<InElementType> InitList)
    {
        DestructItems(GetData(), ArrayNum);
        // This is not strictly legal, as std::initializer_list's iterators are not guaranteed to be pointers, but
        // this appears to be the case on all of our implementations.  Also, if it's not true on a new implementation,
        // it will fail to compile rather than behave badly.
        CopyToEmpty(InitList.begin(), (SizeType)InitList.size(), ArrayMax);
        return *this;
    }
 
    template<typename OtherAllocatorType>
    TArray& operator=(const TArray<ElementType, OtherAllocatorType>& Other)
    {
        DestructItems(GetData(), ArrayNum);
        CopyToEmpty(Other.GetData(), Other.Num(), ArrayMax);
        return *this;
    }
 
    TArray& operator=(const TArray& Other)
    {
        if (this != &Other)
        {
            DestructItems(GetData(), ArrayNum);
            CopyToEmpty(Other.GetData(), Other.Num(), ArrayMax);
        }
        return *this;
    }
 
    template <typename OtherElementType, typename OtherSizeType>
    TArray& operator=(const TArrayView<OtherElementType, OtherSizeType>& Other);
 
private:
 
    UE_FORCEINLINE_HINT void SlackTrackerNumChanged()
    {
#if UE_ENABLE_ARRAY_SLACK_TRACKING
        if constexpr (TAllocatorTraits<InAllocatorType>::SupportsSlackTracking)
        {
            AllocatorInstance.SlackTrackerLogNum(ArrayNum);
        }
#endif
    }
 
    template <typename FromArrayType, typename ToArrayType>
    static UE_FORCEINLINE_HINT void MoveOrCopy(ToArrayType& ToArray, FromArrayType& FromArray, SizeType PrevMax)
    {
        if constexpr (UE::Core::Private::CanMoveTArrayPointersBetweenArrayTypes<FromArrayType, ToArrayType>())
        {
            // Move
 
            static_assert(std::is_same_v<TArray, ToArrayType>, "MoveOrCopy is expected to be called with the current array type as the destination");
 
            using FromAllocatorType = typename FromArrayType::AllocatorType;
            using ToAllocatorType   = typename ToArrayType::AllocatorType;
 
            if constexpr (TCanMoveBetweenAllocators<FromAllocatorType, ToAllocatorType>::Value)
            {
                ToArray.AllocatorInstance.template MoveToEmptyFromOtherAllocator<FromAllocatorType>(FromArray.AllocatorInstance);
            }
            else
            {
                ToArray.AllocatorInstance.MoveToEmpty(FromArray.AllocatorInstance);
            }
 
            ToArray  .ArrayNum = (SizeType)FromArray.ArrayNum;
            ToArray  .ArrayMax = (SizeType)FromArray.ArrayMax;
 
            // Ensure the destination container could hold the source range (when the allocator size types shrink)
            if constexpr (sizeof(USizeType) < sizeof(typename FromArrayType::USizeType))
            {
                if (ToArray.ArrayNum != FromArray.ArrayNum || ToArray.ArrayMax != FromArray.ArrayMax)
                {
                    // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
                    UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)ToArray.ArrayNum);
                }
            }
 
            FromArray.ArrayNum = 0;
            FromArray.ArrayMax = FromArray.AllocatorInstance.GetInitialCapacity();
 
            FromArray.SlackTrackerNumChanged();
            ToArray.SlackTrackerNumChanged();
        }
        else
        {
            // Copy
 
            ToArray.CopyToEmpty(FromArray.GetData(), FromArray.Num(), PrevMax);
        }
    }
 
    template <typename FromArrayType, typename ToArrayType>
    static UE_FORCEINLINE_HINT void MoveOrCopyWithSlack(ToArrayType& ToArray, FromArrayType& FromArray, SizeType PrevMax, SizeType ExtraSlack)
    {
        if constexpr (UE::Core::Private::CanMoveTArrayPointersBetweenArrayTypes<FromArrayType, ToArrayType>())
        {
            // Move
 
            MoveOrCopy(ToArray, FromArray, PrevMax);
 
            USizeType LocalArrayNum = (USizeType)ToArray.ArrayNum;
            USizeType NewMax        = (USizeType)LocalArrayNum + (USizeType)ExtraSlack;
 
            // This should only happen when we've underflowed or overflowed SizeType
            if ((SizeType)NewMax < (SizeType)LocalArrayNum)
            {
                UE::Core::Private::OnInvalidArrayNum((unsigned long long)ExtraSlack);
            }
 
            ToArray.Reserve(NewMax);
        }
        else
        {
            // Copy
 
            ToArray.CopyToEmptyWithSlack(FromArray.GetData(), FromArray.Num(), PrevMax, ExtraSlack);
        }
    }
 
public:
    [[nodiscard]] UE_FORCEINLINE_HINT TArray(TArray&& Other)
    {
        MoveOrCopy(*this, Other, 0);
    }
 
    template <
        typename OtherElementType,
        typename OtherAllocator
        UE_REQUIRES(UE::Core::Private::TArrayElementsAreCompatible_V<ElementType, OtherElementType&&>)
    >
    [[nodiscard]] UE_FORCEINLINE_HINT explicit TArray(TArray<OtherElementType, OtherAllocator>&& Other)
    {
        MoveOrCopy(*this, Other, 0);
    }
 
    template <
        typename OtherElementType
        UE_REQUIRES(UE::Core::Private::TArrayElementsAreCompatible_V<ElementType, OtherElementType&&>)
    >
    [[nodiscard]] TArray(TArray<OtherElementType, AllocatorType>&& Other, SizeType ExtraSlack)
    {
        MoveOrCopyWithSlack(*this, Other, 0, ExtraSlack);
    }
 
    TArray& operator=(TArray&& Other)
    {
        if (this != &Other)
        {
            DestructItems(GetData(), ArrayNum);
            MoveOrCopy(*this, Other, ArrayMax);
        }
        return *this;
    }
 
    ~TArray()
    {
        UE_STATIC_ASSERT_WARN(TIsTriviallyRelocatable_V<InElementType>, "TArray can only be used with trivially relocatable types");
 
        DestructItems(GetData(), ArrayNum);
 
        // note ArrayNum, ArrayMax and data pointer are not invalidated
        // they are left unchanged and use-after-destruct will see them the same as before destruct
    }
 
    // Start - intrusive TOptional<TArray> state //
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = TArray;
 
    UE_NODEBUG [[nodiscard]] explicit TArray(FIntrusiveUnsetOptionalState Tag)
        : ArrayNum(0)
        , ArrayMax(-1)
    {
        // Use ArrayMax == -1 as our intrusive state so that the destructor still works without change, as it doesn't use ArrayMax.
    }
    UE_NODEBUG [[nodiscard]] bool operator==(FIntrusiveUnsetOptionalState Tag) const
    {
        return ArrayMax == -1;
    }
    // End - intrusive TOptional<TArray> state //
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType* GetData() UE_LIFETIMEBOUND
    {
        return (ElementType*)AllocatorInstance.GetAllocation();
    }
 
    [[nodiscard]] UE_REWRITE const ElementType* GetData() const UE_LIFETIMEBOUND
    {
        return const_cast<TArray*>(this)->GetData();
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT static constexpr uint32 GetTypeSize()
    {
        return sizeof(ElementType);
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT SIZE_T GetAllocatedSize(void) const
    {
        return AllocatorInstance.GetAllocatedSize(ArrayMax, sizeof(ElementType));
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT SizeType GetSlack() const
    {
        return ArrayMax - ArrayNum;
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT void CheckInvariants() const
    {
        checkSlow((ArrayNum >= 0) & (ArrayMax >= ArrayNum)); // & for one branch
    }
 
    UE_FORCEINLINE_HINT void RangeCheck(SizeType Index) const
    {
        CheckInvariants();
 
        // Template property, branch will be optimized out
        if constexpr (AllocatorType::RequireRangeCheck)
        {
            checkf((Index >= 0) & (Index < ArrayNum),TEXT("Array index out of bounds: %lld into an array of size %lld"),(long long)Index, (long long)ArrayNum); // & for one branch
        }
    }
 
    UE_FORCEINLINE_HINT void RangeCheck(SizeType Index, SizeType Count) const
    {
        CheckInvariants();
 
        // Template property, branch will be optimized out
        if constexpr (AllocatorType::RequireRangeCheck)
        {
            checkf((Count >= 0) & (Index >= 0) & (Index + Count <= ArrayNum), TEXT("Array range out of bounds: index %lld and length %lld into an array of size %lld"), (long long)Index, (long long)Count, (long long)ArrayNum); // & for one branch
        }
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT bool IsValidIndex(SizeType Index) const
    {
        return Index >= 0 && Index < ArrayNum;
    }
 
    [[nodiscard]] UE_REWRITE bool IsEmpty() const
    {
        return ArrayNum == 0;
    }
 
    [[nodiscard]] UE_REWRITE SizeType Num() const
    {
        return ArrayNum;
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT SIZE_T NumBytes() const
    {
        return static_cast<SIZE_T>(ArrayNum) * sizeof(ElementType);
    }
 
    [[nodiscard]] UE_REWRITE SizeType Max() const
    {
        return ArrayMax;
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& operator[](SizeType Index) UE_LIFETIMEBOUND
    {
        RangeCheck(Index);
        return GetData()[Index];
    }
 
    [[nodiscard]] UE_REWRITE const ElementType& operator[](SizeType Index) const UE_LIFETIMEBOUND
    {
        return (*const_cast<TArray*>(this))[Index];
    }
 
    ElementType Pop(EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        RangeCheck(0);
        ElementType Result = MoveTempIfPossible(GetData()[ArrayNum - 1]);
        RemoveAtImpl(ArrayNum - 1);
        if (AllowShrinking == EAllowShrinking::Yes)
        {
            UE::Core::Private::ReallocShrink<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
        return Result;
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("Pop")
    UE_NODEBUG UE_FORCEINLINE_HINT ElementType Pop(bool bAllowShrinking)
    {
        return Pop(bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT void Push(ElementType&& Item)
    {
        Add(MoveTempIfPossible(Item));
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT void Push(const ElementType& Item)
    {
        Add(Item);
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& Top() UE_LIFETIMEBOUND
    {
        return Last();
    }
    [[nodiscard]] UE_REWRITE const ElementType& Top() const UE_LIFETIMEBOUND
    {
        return const_cast<TArray*>(this)->Top();
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& Last(SizeType IndexFromTheEnd = 0) UE_LIFETIMEBOUND
    {
        RangeCheck(ArrayNum - IndexFromTheEnd - 1);
        return GetData()[ArrayNum - IndexFromTheEnd - 1];
    }
    [[nodiscard]] UE_REWRITE const ElementType& Last(SizeType IndexFromTheEnd = 0) const UE_LIFETIMEBOUND
    {
        return const_cast<TArray*>(this)->Last(IndexFromTheEnd);
    }
 
    UE_FORCEINLINE_HINT void Shrink()
    {
        CheckInvariants();
        if (ArrayMax != ArrayNum)
        {
            UE::Core::Private::ReallocTo<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                ArrayNum,
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT bool Find(const ElementType& Item, SizeType& Index) const
    {
        Index = this->Find(Item);
        return Index != INDEX_NONE;
    }
 
    [[nodiscard]] SizeType Find(const ElementType& Item) const
    {
        const ElementType* RESTRICT Start = GetData();
        for (const ElementType* RESTRICT Data = Start, *RESTRICT DataEnd = Data + ArrayNum; Data != DataEnd; ++Data)
        {
            if (*Data == Item)
            {
                return static_cast<SizeType>(Data - Start);
            }
        }
        return INDEX_NONE;
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT bool FindLast(const ElementType& Item, SizeType& Index) const
    {
        Index = this->FindLast(Item);
        return Index != INDEX_NONE;
    }
 
    [[nodiscard]] SizeType FindLast(const ElementType& Item) const
    {
        for (const ElementType* RESTRICT Start = GetData(), *RESTRICT Data = Start + ArrayNum; Data != Start; )
        {
            --Data;
            if (*Data == Item)
            {
                return static_cast<SizeType>(Data - Start);
            }
        }
        return INDEX_NONE;
    }
 
    template <typename Predicate>
    [[nodiscard]] SizeType FindLastByPredicate(Predicate Pred, SizeType Count) const
    {
        check(Count >= 0 && Count <= this->Num());
        for (const ElementType* RESTRICT Start = GetData(), *RESTRICT Data = Start + Count; Data != Start; )
        {
            --Data;
            if (::Invoke(Pred, *Data))
            {
                return static_cast<SizeType>(Data - Start);
            }
        }
        return INDEX_NONE;
    }
 
    template <typename Predicate>
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT SizeType FindLastByPredicate(Predicate Pred) const
    {
        return FindLastByPredicate(Pred, ArrayNum);
    }
 
    template <typename KeyType>
    [[nodiscard]] SizeType IndexOfByKey(const KeyType& Key) const
    {
        const ElementType* RESTRICT Start = GetData();
        for (const ElementType* RESTRICT Data = Start, *RESTRICT DataEnd = Start + ArrayNum; Data != DataEnd; ++Data)
        {
            if (*Data == Key)
            {
                return static_cast<SizeType>(Data - Start);
            }
        }
        return INDEX_NONE;
    }
 
    template <typename Predicate>
    [[nodiscard]] SizeType IndexOfByPredicate(Predicate Pred) const
    {
        const ElementType* RESTRICT Start = GetData();
        for (const ElementType* RESTRICT Data = Start, *RESTRICT DataEnd = Start + ArrayNum; Data != DataEnd; ++Data)
        {
            if (::Invoke(Pred, *Data))
            {
                return static_cast<SizeType>(Data - Start);
            }
        }
        return INDEX_NONE;
    }
 
    template <typename KeyType>
    [[nodiscard]] ElementType* FindByKey(const KeyType& Key)
    {
        for (ElementType* RESTRICT Data = GetData(), *RESTRICT DataEnd = Data + ArrayNum; Data != DataEnd; ++Data)
        {
            if (*Data == Key)
            {
                return Data;
            }
        }
 
        return nullptr;
    }
    template <typename KeyType>
    [[nodiscard]] UE_REWRITE const ElementType* FindByKey(const KeyType& Key) const
    {
        return const_cast<TArray*>(this)->FindByKey(Key);
    }
 
    template <typename Predicate>
    [[nodiscard]] ElementType* FindByPredicate(Predicate Pred)
    {
        for (ElementType* RESTRICT Data = GetData(), *RESTRICT DataEnd = Data + ArrayNum; Data != DataEnd; ++Data)
        {
            if (::Invoke(Pred, *Data))
            {
                return Data;
            }
        }
 
        return nullptr;
    }
    template <typename Predicate>
    [[nodiscard]] UE_REWRITE const ElementType* FindByPredicate(Predicate Pred) const
    {
        return const_cast<TArray*>(this)->FindByPredicate(Pred);
    }
 
    template <typename Predicate>
    [[nodiscard]] TArray<ElementType> FilterByPredicate(Predicate Pred) const
    {
        TArray<ElementType> FilterResults;
        for (const ElementType* RESTRICT Data = GetData(), *RESTRICT DataEnd = Data + ArrayNum; Data != DataEnd; ++Data)
        {
            if (::Invoke(Pred, *Data))
            {
                FilterResults.Add(*Data);
            }
        }
        return FilterResults;
    }
 
    template <typename ComparisonType>
    [[nodiscard]] bool Contains(const ComparisonType& Item) const
    {
        for (const ElementType* RESTRICT Data = GetData(), *RESTRICT DataEnd = Data + ArrayNum; Data != DataEnd; ++Data)
        {
            if (*Data == Item)
            {
                return true;
            }
        }
        return false;
    }
 
    template <typename Predicate>
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT bool ContainsByPredicate(Predicate Pred) const
    {
        return FindByPredicate(Pred) != nullptr;
    }
 
    UE_NODEBUG [[nodiscard]] bool operator==(const TArray& OtherArray) const
    {
        SizeType Count = Num();
 
        return Count == OtherArray.Num() && CompareItems(GetData(), OtherArray.GetData(), Count);
    }
 
#if !PLATFORM_COMPILER_HAS_GENERATED_COMPARISON_OPERATORS
    [[nodiscard]] UE_REWRITE bool operator!=(const TArray& OtherArray) const
    {
        return !(*this == OtherArray);
    }
#endif
 
    void BulkSerialize(FArchive& Ar, bool bForcePerElementSerialization = false)
    {
        constexpr int32 ElementSize = sizeof(ElementType);
        // Serialize element size to detect mismatch across platforms.
        int32 SerializedElementSize = ElementSize;
        Ar << SerializedElementSize;
 
        if (bForcePerElementSerialization
            || (Ar.IsSaving()           // if we are saving, we always do the ordinary serialize as a way to make sure it matches up with bulk serialization
            && !Ar.IsCooking()          // but cooking and transacting is performance critical, so we skip that
            && !Ar.IsTransacting())
            || Ar.IsByteSwapping()      // if we are byteswapping, we need to do that per-element
            )
        {
            Ar << *this;
        }
        else
        {
            CountBytes(Ar);
            if (Ar.IsLoading())
            {
                // Basic sanity checking to ensure that sizes match.
                if (!ensure(SerializedElementSize == ElementSize))
                {
                    Ar.SetError();
                    return;
                }
 
                // Serialize the number of elements, block allocate the right amount of memory and deserialize
                // the data as a giant memory blob in a single call to Serialize. Please see the function header
                // for detailed documentation on limitations and implications.
                SizeType NewArrayNum = 0;
                Ar << NewArrayNum;
                if (!ensure(NewArrayNum >= 0 && std::numeric_limits<SizeType>::max() / (SizeType)ElementSize >= NewArrayNum))
                {
                    Ar.SetError();
                    return;
                }
                Empty(NewArrayNum);
                AddUninitialized(NewArrayNum);
                Ar.Serialize(GetData(), (int64)NewArrayNum * (int64)ElementSize);
            }
            else if (Ar.IsSaving())
            {
                SizeType ArrayCount = Num();
                Ar << ArrayCount;
                Ar.Serialize(GetData(), (int64)ArrayCount * (int64)ElementSize);
            }
        }
    }
 
    UE_NODEBUG void CountBytes(FArchive& Ar) const
    {
        Ar.CountBytes(ArrayNum*sizeof(ElementType), ArrayMax*sizeof(ElementType));
    }
 
    UE_FORCEINLINE_HINT SizeType AddUninitialized()
    {
        // Begin sensitive code! Single element additions/insertions get inlined _everywhere_ and thus
        // punch above their weight with respect to exe size, so we pay a lot of attention to every instruction
        // here until we get in to the NOINLINE functions that actually handle the growth.
 
        // Modulo some register allocation and pointer offsets, inlined sites on x64 for the "Tiny" path should look roughly like:
        //
        // mov eax, dword ptr [array + 8h] // load arraynum
        // cmp eax, dword ptr [array + 0Ch] // load arraymax
        // jne [to ArrayNum++]
        // mov ecx, immediate representing size/alignment
        // lea r8, [array + 0Ch]] // array max
        // lea rdx, [array] // allocator instance
        // call
        // lea ecx, [rax+1] // ArrayNum++
        // mov dword ptr [array + 8h], ecx // Save ArrayNum
        //
 
        // Single cmp, which we can assume because we are adding a single element.
        if (ArrayNum == ArrayMax)
        {
            // Both branches here write the return in to ArrayNum. This is because the function call clobbers the registers
            // and if we assign as part of the return into something we need, the compiler doesn't have to reload the data
            // into the clobbered register.
 
            // When we can pack size and alignment into a single 16 bit load, we save a parameter setup instruction
            // for the function call. The 16 bit part is load-bearing for arm codegen.
            // PVS believes this is overwrought because technically sizeof() <= 255 implies alignof <= 255. I think this is far more
            // clear and costs nothing.
            if constexpr (sizeof(ElementType) <= 255 && alignof(ElementType) <= 255) // -V590
            {
                // Note that the realloc functions are templated ONLY on allocator instance so they are not duplicated
                // in the code for every type!
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc_Tiny<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType) | (alignof(ElementType) << 8), AllocatorInstance, ArrayMax);
            }
            else
            {
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType), alignof(ElementType), AllocatorInstance, ArrayMax);
            }
        }
        // End sensitive code!
 
        SizeType OldArrayNum = ArrayNum;
        ArrayNum++;
        return OldArrayNum;
    }
    UE_FORCEINLINE_HINT SizeType AddUninitialized(SizeType Count)
    {
        // Should be SetNumUninitialized?
        return UE::Core::Private::ReallocGrow<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
            sizeof(ElementType),
            alignof(ElementType),
            Count,
            AllocatorInstance,
            ArrayNum,
            ArrayMax
        );
    }
 
private:
    void InsertUninitializedImpl(SizeType Index)
    {
        // Begin sensitive code! See comments in AddUninitialized() before touching!
        if (ArrayNum == ArrayMax)
        {
            if constexpr (sizeof(ElementType) <= 255 && alignof(ElementType) <= 255) // -V590
            {
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc_Tiny<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType) | (alignof(ElementType) << 8), AllocatorInstance, ArrayMax);
            }
            else
            {
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType), alignof(ElementType), AllocatorInstance, ArrayMax);
            }
        }
        // End sensitive code!
        SizeType OldNum = ArrayNum;
        ArrayNum++;
        ElementType* Data = GetData() + Index;
        RelocateConstructItems<ElementType>((void*)(Data + 1), Data, OldNum - Index);
    }
    void InsertUninitializedImpl(SizeType Index, SizeType Count)
    {
        // Should be SetNumUninitialized?
        SizeType OldNum = UE::Core::Private::ReallocGrow<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
            sizeof(ElementType),
            alignof(ElementType),
            Count,
            AllocatorInstance,
            ArrayNum,
            ArrayMax
        );
        ElementType* Data = GetData() + Index;
        RelocateConstructItems<ElementType>((void*)(Data + Count), Data, OldNum - Index);
    }
    template <
        typename OtherSizeType
        UE_REQUIRES(sizeof(OtherSizeType) > sizeof(SizeType))
    >
    UE_NODEBUG void InsertUninitializedImpl(SizeType Index, OtherSizeType Count)
    {
        checkf((OtherSizeType)(SizeType)Count == Count, TEXT("Invalid number of elements to add to this array type: %lld"), (long long)(SizeType)Count);
        return InsertUninitializedImpl(Index, (SizeType)Count);
    }
 
public:
    UE_NODEBUG UE_FORCEINLINE_HINT void InsertUninitialized(SizeType Index)
    {
        InsertUninitializedImpl(Index);
    }
    UE_NODEBUG UE_FORCEINLINE_HINT void InsertUninitialized(SizeType Index, SizeType Count)
    {
        InsertUninitializedImpl(Index, Count);
    }
 
    void InsertZeroed(SizeType Index)
    {
        InsertUninitializedImpl(Index);
        FMemory::Memzero(GetData() + Index, sizeof(ElementType));
    }
    void InsertZeroed(SizeType Index, SizeType Count)
    {
        InsertUninitializedImpl(Index, Count);
        FMemory::Memzero(GetData() + Index, Count * sizeof(ElementType));
    }
 
    ElementType& InsertZeroed_GetRef(SizeType Index) UE_LIFETIMEBOUND
    {
        InsertUninitializedImpl(Index, 1);
        ElementType* Ptr = GetData() + Index;
        FMemory::Memzero(Ptr, sizeof(ElementType));
        return *Ptr;
    }
 
    void InsertDefaulted(SizeType Index)
    {
        InsertUninitializedImpl(Index);
        DefaultConstructItems<ElementType>((void*)(GetData() + Index), 1);
    }
    void InsertDefaulted(SizeType Index, SizeType Count)
    {
        InsertUninitializedImpl(Index, Count);
        DefaultConstructItems<ElementType>((void*)(GetData() + Index), Count);
    }
 
    ElementType& InsertDefaulted_GetRef(SizeType Index) UE_LIFETIMEBOUND
    {
        InsertUninitializedImpl(Index, 1);
        ElementType* Ptr = GetData() + Index;
        DefaultConstructItems<ElementType>((void*)Ptr, 1);
        return *Ptr;
    }
 
    SizeType Insert(std::initializer_list<ElementType> InitList, const SizeType InIndex)
    {
        SizeType NumNewElements = (SizeType)InitList.size();
 
        InsertUninitializedImpl(InIndex, NumNewElements);
        ConstructItems<ElementType>((void*)(GetData() + InIndex), InitList.begin(), NumNewElements);
 
        return InIndex;
    }
 
    template <typename OtherAllocator>
    SizeType Insert(const TArray<ElementType, OtherAllocator>& Items, const SizeType InIndex)
    {
        check((const void*)this != (const void*)&Items);
 
        auto NumNewElements = Items.Num();
 
        InsertUninitializedImpl(InIndex, NumNewElements);
        ConstructItems<ElementType>((void*)(GetData() + InIndex), Items.GetData(), NumNewElements);
 
        return InIndex;
    }
 
    template <typename OtherAllocator>
    SizeType Insert(TArray<ElementType, OtherAllocator>&& Items, const SizeType InIndex)
    {
        check((const void*)this != (const void*)&Items);
 
        auto NumNewElements = Items.Num();
 
        InsertUninitializedImpl(InIndex, NumNewElements);
        RelocateConstructItems<ElementType>((void*)(GetData() + InIndex), Items.GetData(), NumNewElements);
        Items.ArrayNum = 0;
 
        Items.SlackTrackerNumChanged();
 
        return InIndex;
    }
 
    SizeType Insert(const ElementType* Ptr, SizeType Count, SizeType Index)
    {
        check(Ptr != nullptr);
 
        InsertUninitializedImpl(Index, Count);
        ConstructItems<ElementType>((void*)(GetData() + Index), Ptr, Count);
 
        return Index;
    }
 
    UE_FORCEINLINE_HINT void CheckAddress(const ElementType* Addr) const
    {
        checkf(Addr < GetData() || Addr >= (GetData() + ArrayMax), TEXT("Attempting to use a container element (%p) which already comes from the container being modified (%p, ArrayMax: %lld, ArrayNum: %lld, SizeofElement: %zu)!"), Addr, GetData(), (long long)ArrayMax, (long long)ArrayNum, sizeof(ElementType));
    }
 
    SizeType Insert(ElementType&& Item, SizeType Index)
    {
        CheckAddress(&Item);
 
        // construct a copy in place at Index (this new operator will insert at
        // Index, then construct that memory with Item)
        InsertUninitializedImpl(Index);
        ::new((void*)(GetData() + Index)) ElementType(MoveTempIfPossible(Item));
        return Index;
    }
 
    SizeType Insert(const ElementType& Item, SizeType Index)
    {
        CheckAddress(&Item);
 
        // construct a copy in place at Index (this new operator will insert at
        // Index, then construct that memory with Item)
        InsertUninitializedImpl(Index);
        ::new((void*)(GetData() + Index)) ElementType(Item);
        return Index;
    }
 
    [[nodiscard]] ElementType& Insert_GetRef(ElementType&& Item, SizeType Index) UE_LIFETIMEBOUND
    {
        CheckAddress(&Item);
 
        // construct a copy in place at Index (this new operator will insert at
        // Index, then construct that memory with Item)
        InsertUninitializedImpl(Index);
        ElementType* Ptr = GetData() + Index;
        ::new((void*)Ptr) ElementType(MoveTempIfPossible(Item));
        return *Ptr;
    }
 
    [[nodiscard]] ElementType& Insert_GetRef(const ElementType& Item, SizeType Index) UE_LIFETIMEBOUND
    {
        CheckAddress(&Item);
 
        // construct a copy in place at Index (this new operator will insert at
        // Index, then construct that memory with Item)
        InsertUninitializedImpl(Index);
        ElementType* Ptr = GetData() + Index;
        ::new((void*)Ptr) ElementType(Item);
        return *Ptr;
    }
 
private:
    void RemoveAtImpl(SizeType Index)
    {
        ElementType* Dest = GetData() + Index;
 
        DestructItem(Dest);
 
        // Skip relocation in the common case that there is nothing to move.
        SizeType NumToMove = (ArrayNum - Index) - 1;
        if (NumToMove)
        {
            RelocateConstructItems<ElementType>((void*)Dest, Dest + 1, NumToMove);
        }
        --ArrayNum;
 
        SlackTrackerNumChanged();
    }
 
    void RemoveAtImpl(SizeType Index, SizeType Count)
    {
        ElementType* Dest = GetData() + Index;
 
        DestructItems(Dest, Count);
 
        // Skip relocation in the common case that there is nothing to move.
        SizeType NumToMove = (ArrayNum - Index) - Count;
        if (NumToMove)
        {
            RelocateConstructItems<ElementType>((void*)Dest, Dest + Count, NumToMove);
        }
        ArrayNum -= Count;
 
        SlackTrackerNumChanged();
    }
 
public:
    void RemoveAt(SizeType Index, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        RangeCheck(Index);
        RemoveAtImpl(Index);
        if (AllowShrinking == EAllowShrinking::Yes)
        {
            UE::Core::Private::ReallocShrink<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
    }
 
    template <UE::CIntegral CountType>
    UE_FORCEINLINE_HINT void RemoveAt(SizeType Index, CountType Count, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        static_assert(!std::is_same_v<CountType, bool>, "TArray::RemoveAt: unexpected bool passed as the Count argument");
        RangeCheck(Index, Count);
        if (Count)
        {
            RemoveAtImpl(Index, (SizeType)Count);
            if (AllowShrinking == EAllowShrinking::Yes)
            {
                UE::Core::Private::ReallocShrink<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                    sizeof(ElementType),
                    alignof(ElementType),
                    AllocatorInstance,
                    ArrayNum,
                    ArrayMax
                );
            }
        }
    }
    template <typename CountType>
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveAt")
    UE_FORCEINLINE_HINT void RemoveAt(SizeType Index, CountType Count, bool bAllowShrinking)
    {
        RemoveAt(Index, Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
private:
    void RemoveAtSwapImpl(SizeType Index)
    {
        ElementType* Data = GetData();
        ElementType* Dest = Data + Index;
 
        DestructItem(Dest);
 
        // Replace the elements in the hole created by the removal with elements from the end of the array, so the range of indices used by the array is contiguous.
        const SizeType NumElementsAfterHole = (ArrayNum - Index) - 1;
        const SizeType NumElementsToMoveIntoHole = FPlatformMath::Min(1, NumElementsAfterHole);
        if (NumElementsToMoveIntoHole)
        {
            RelocateConstructItems<ElementType>((void*)Dest, Data + (ArrayNum - NumElementsToMoveIntoHole), NumElementsToMoveIntoHole);
        }
        --ArrayNum;
 
        SlackTrackerNumChanged();
    }
 
    void RemoveAtSwapImpl(SizeType Index, SizeType Count)
    {
        ElementType* Data = GetData();
        ElementType* Dest = Data + Index;
 
        DestructItems(Dest, Count);
 
        // Replace the elements in the hole created by the removal with elements from the end of the array, so the range of indices used by the array is contiguous.
        const SizeType NumElementsAfterHole = (ArrayNum - Index) - Count;
        const SizeType NumElementsToMoveIntoHole = FPlatformMath::Min(Count, NumElementsAfterHole);
        if (NumElementsToMoveIntoHole)
        {
            RelocateConstructItems<ElementType>((void*)Dest, Data + (ArrayNum - NumElementsToMoveIntoHole), NumElementsToMoveIntoHole);
        }
        ArrayNum -= Count;
 
        SlackTrackerNumChanged();
    }
 
public:
    UE_FORCEINLINE_HINT void RemoveAtSwap(SizeType Index, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        RangeCheck(Index);
        RemoveAtSwapImpl(Index);
        if (AllowShrinking == EAllowShrinking::Yes)
        {
            UE::Core::Private::ReallocShrink<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
    }
 
    template <UE::CIntegral CountType>
    UE_FORCEINLINE_HINT void RemoveAtSwap(SizeType Index, CountType Count, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        static_assert(!std::is_same_v<CountType, bool>, "TArray::RemoveAtSwap: unexpected bool passed as the Count argument");
        RangeCheck(Index, Count);
        if (Count)
        {
            RemoveAtSwapImpl(Index, Count);
            if (AllowShrinking == EAllowShrinking::Yes)
            {
                UE::Core::Private::ReallocShrink<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                    sizeof(ElementType),
                    alignof(ElementType),
                    AllocatorInstance,
                    ArrayNum,
                    ArrayMax
                );
            }
        }
    }
    template <typename CountType>
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveAtSwap")
    UE_NODEBUG UE_FORCEINLINE_HINT void RemoveAtSwap(SizeType Index, CountType Count, bool bAllowShrinking)
    {
        RemoveAtSwap(Index, Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    void Reset(SizeType NewSize = 0)
    {
        if (NewSize < 0)
        {
            // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
            UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)NewSize);
        }
 
        // If we have space to hold the expected size, then don't reallocate
        if (NewSize <= ArrayMax)
        {
            DestructItems(GetData(), ArrayNum);
            ArrayNum = 0;
 
            SlackTrackerNumChanged();
        }
        else
        {
            Empty(NewSize);
        }
    }
 
    void Empty(SizeType Slack = 0)
    {
        if (Slack < 0)
        {
            // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
            UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)Slack);
        }
 
        DestructItems(GetData(), ArrayNum);
 
        checkSlow(Slack >= 0);
        ArrayNum = 0;
 
        SlackTrackerNumChanged();
 
        if (ArrayMax != Slack)
        {
            UE::Core::Private::ReallocTo<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                Slack,
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
    }
 
    void SetNum(SizeType NewNum, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        if (NewNum > Num())
        {
            const SizeType Diff = NewNum - ArrayNum;
            const SizeType Index = AddUninitialized(Diff);
            DefaultConstructItems<ElementType>((void*)((uint8*)AllocatorInstance.GetAllocation() + Index * sizeof(ElementType)), Diff);
        }
        else if (NewNum < 0)
        {
            // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
            UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)NewNum);
        }
        else if (NewNum < Num())
        {
            RemoveAt(NewNum, Num() - NewNum, AllowShrinking);
        }
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("SetNum")
    UE_NODEBUG UE_FORCEINLINE_HINT void SetNum(SizeType NewNum, bool bAllowShrinking)
    {
        SetNum(NewNum, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    void SetNumZeroed(SizeType NewNum, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        if (NewNum > Num())
        {
            AddZeroed(NewNum - Num());
        }
        else if (NewNum < 0)
        {
            // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
            UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)NewNum);
        }
        else if (NewNum < Num())
        {
            RemoveAt(NewNum, Num() - NewNum, AllowShrinking);
        }
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("SetNumZeroed")
    UE_NODEBUG UE_FORCEINLINE_HINT void SetNumZeroed(SizeType NewNum, bool bAllowShrinking)
    {
        SetNumZeroed(NewNum, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    void SetNumUninitialized(SizeType NewNum, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        if (NewNum > Num())
        {
            AddUninitialized(NewNum - Num());
        }
        else if (NewNum < 0)
        {
            // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
            UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)NewNum);
        }
        else if (NewNum < Num())
        {
            RemoveAt(NewNum, Num() - NewNum, AllowShrinking);
        }
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("SetNumUninitialized")
    UE_NODEBUG UE_FORCEINLINE_HINT void SetNumUninitialized(SizeType NewNum, bool bAllowShrinking)
    {
        SetNumUninitialized(NewNum, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    void SetNumUnsafeInternal(SizeType NewNum)
    {
        checkSlow(NewNum <= Num() && NewNum >= 0);
        ArrayNum = NewNum;
 
        SlackTrackerNumChanged();
    }
 
    template <typename OtherElementType, typename OtherAllocatorType>
    void Append(const TArray<OtherElementType, OtherAllocatorType>& Source)
    {
        check((void*)this != (void*)&Source);
 
        SizeType SourceCount = Source.Num();
 
        // Do nothing if the source is empty.
        if (!SourceCount)
        {
            return;
        }
 
        // Allocate memory for the new elements.
        SizeType Pos = AddUninitialized(SourceCount);
        ConstructItems<ElementType>((void*)(GetData() + Pos), Source.GetData(), SourceCount);
    }
 
    template <typename OtherElementType, typename OtherAllocator>
    void Append(TArray<OtherElementType, OtherAllocator>&& Source)
    {
        check((void*)this != (void*)&Source);
 
        SizeType SourceCount = Source.Num();
 
        // Do nothing if the source is empty.
        if (!SourceCount)
        {
            return;
        }
 
        // Allocate memory for the new elements.
        SizeType Pos = AddUninitialized(SourceCount);
        RelocateConstructItems<ElementType>((void*)(GetData() + Pos), Source.GetData(), SourceCount);
        Source.ArrayNum = 0;
 
        Source.SlackTrackerNumChanged();
    }
 
    template <
        typename RangeType
        UE_REQUIRES(
            TIsContiguousContainer<RangeType>::Value &&
            !UE::Core::Private::TIsTArrayOrDerivedFromTArray_V<std::remove_reference_t<RangeType>> &&
            UE::Core::Private::TArrayElementsAreCompatible_V<ElementType, TElementType_T<RangeType>>
        )
    >
    void Append(RangeType&& Source)
    {
        auto InCount = GetNum(Source);
        checkf((InCount >= 0) && ((sizeof(InCount) < sizeof(SizeType)) || (InCount <= static_cast<decltype(InCount)>(TNumericLimits<SizeType>::Max()))), TEXT("Invalid range size: %lld"), (long long)InCount);
 
        // Do nothing if the source is empty.
        if (!InCount)
        {
            return;
        }
 
        SizeType SourceCount = (SizeType)InCount;
 
        // Allocate memory for the new elements.
        SizeType Pos = AddUninitialized(SourceCount);
        ConstructItems<ElementType>((void*)(GetData() + Pos), UE::Core::Private::GetDataHelper(Source), SourceCount);
    }
 
    void Append(const ElementType* Ptr, SizeType Count)
    {
        check(Ptr != nullptr || Count == 0);
 
        SizeType Pos = AddUninitialized(Count);
        ConstructItems<ElementType>((void*)(GetData() + Pos), Ptr, Count);
    }
 
    UE_FORCEINLINE_HINT void Append(std::initializer_list<ElementType> InitList)
    {
        SizeType Count = (SizeType)InitList.size();
 
        SizeType Pos = AddUninitialized(Count);
        ConstructItems<ElementType>((void*)(GetData() + Pos), InitList.begin(), Count);
    }
 
    UE_NODEBUG TArray& operator+=(TArray&& Other)
    {
        Append(MoveTemp(Other));
        return *this;
    }
 
    UE_NODEBUG TArray& operator+=(const TArray& Other)
    {
        Append(Other);
        return *this;
    }
 
    UE_NODEBUG TArray& operator+=(std::initializer_list<ElementType> InitList)
    {
        Append(InitList);
        return *this;
    }
 
    template <typename... ArgsType>
    UE_FORCEINLINE_HINT SizeType Emplace(ArgsType&&... Args)
    {
        // If this fails to compile when trying to call Emplace with a non-public constructor,
        // do not make TArray a friend.
        //
        // Instead, prefer this pattern:
        //
        //     class FMyType
        //     {
        //     private:
        //         struct FPrivateToken { explicit FPrivateToken() = default; };
        //
        //     public:
        //         // This has an equivalent access level to a private constructor,
        //         // as only friends of FMyType will have access to FPrivateToken,
        //         // but Emplace can legally call it since it's public.
        //         explicit FMyType(FPrivateToken, int32 Int, float Real, const TCHAR* String);
        //     };
        //
        //     TArray<FMyType> Arr:
        //
        //     // Won't compile if the caller doesn't have access to FMyType::FPrivateToken
        //     Arr.Emplace(FMyType::FPrivateToken{}, 5, 3.14f, TEXT("Banana"));
        //
 
        // Begin sensitive code! See comments in AddUninitialized() before touching!
        if (ArrayNum == ArrayMax)
        {
            if constexpr (sizeof(ElementType) <= 255 && alignof(ElementType) <= 255) // -V590
            {
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc_Tiny<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType) | (alignof(ElementType) << 8), AllocatorInstance, ArrayMax);
            }
            else
            {
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType), alignof(ElementType), AllocatorInstance, ArrayMax);
            }
        }
        // End sensitive code!
        SizeType OldArrayNum = ArrayNum;
        ArrayNum++;
        void* Ptr = (char*)AllocatorInstance.GetAllocation() + sizeof(ElementType) * OldArrayNum;
        (void)new (Ptr) ElementType(Forward<ArgsType>(Args)...);
        return OldArrayNum;
    }
 
    template <typename... ArgsType>
    [[nodiscard]] UE_FORCEINLINE_HINT ElementType& Emplace_GetRef(ArgsType&&... Args) UE_LIFETIMEBOUND
    {
        // If this fails to compile when trying to call Emplace with a non-public constructor,
        // do not make TArray a friend.
        //
        // Instead, prefer this pattern:
        //
        //     class FMyType
        //     {
        //     private:
        //         struct FPrivateToken { explicit FPrivateToken() = default; };
        //
        //     public:
        //         // This has an equivalent access level to a private constructor,
        //         // as only friends of FMyType will have access to FPrivateToken,
        //         // but Emplace can legally call it since it's public.
        //         explicit FMyType(FPrivateToken, int32 Int, float Real, const TCHAR* String);
        //     };
        //
        //     TArray<FMyType> Arr:
        //
        //     // Won't compile if the caller doesn't have access to FMyType::FPrivateToken
        //     Arr.Emplace(FMyType::FPrivateToken{}, 5, 3.14f, TEXT("Banana"));
        //
        // Begin sensitive code! See comments in AddUninitialized() before touching!
        if (ArrayNum == ArrayMax)
        {
            if constexpr (sizeof(ElementType) <= 255 && alignof(ElementType) <= 255) // -V590
            {
                // Looks weird but saves the register reload
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc_Tiny<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType) | (alignof(ElementType) << 8), AllocatorInstance, ArrayMax);
            }
            else
            {
                // Looks weird but saves the register reload
                ArrayNum = UE::Core::Private::ReallocGrow1_DoAlloc<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(sizeof(ElementType), alignof(ElementType), AllocatorInstance, ArrayMax);
            }
        }
        // End sensitive code!
        SizeType OldArrayNum = ArrayNum;
        ArrayNum++;
        void* Ptr = (char*)AllocatorInstance.GetAllocation() + sizeof(ElementType) * OldArrayNum;
        return *new (Ptr) ElementType(Forward<ArgsType>(Args)...);
    }
 
    template <typename... ArgsType>
    UE_FORCEINLINE_HINT void EmplaceAt(SizeType Index, ArgsType&&... Args)
    {
        InsertUninitializedImpl(Index, 1);
        ::new((void*)(GetData() + Index)) ElementType(Forward<ArgsType>(Args)...);
    }
 
    template <typename... ArgsType>
    [[nodiscard]] UE_FORCEINLINE_HINT ElementType& EmplaceAt_GetRef(SizeType Index, ArgsType&&... Args) UE_LIFETIMEBOUND
    {
        InsertUninitializedImpl(Index, 1);
        ElementType* Ptr = GetData() + Index;
        ::new((void*)Ptr) ElementType(Forward<ArgsType>(Args)...);
        return *Ptr;
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT SizeType Add(ElementType&& Item)
    {
        CheckAddress(&Item);
        return Emplace(MoveTempIfPossible(Item));
    }
 
    UE_NODEBUG UE_FORCEINLINE_HINT SizeType Add(const ElementType& Item)
    {
        CheckAddress(&Item);
        return Emplace(Item);
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& Add_GetRef(ElementType&& Item) UE_LIFETIMEBOUND
    {
        CheckAddress(&Item);
        return Emplace_GetRef(MoveTempIfPossible(Item));
    }
 
    UE_NODEBUG [[nodiscard]] UE_FORCEINLINE_HINT ElementType& Add_GetRef(const ElementType& Item) UE_LIFETIMEBOUND
    {
        CheckAddress(&Item);
        return Emplace_GetRef(Item);
    }
 
    SizeType AddZeroed()
    {
        const SizeType Index = AddUninitialized();
        FMemory::Memzero((uint8*)AllocatorInstance.GetAllocation() + Index * sizeof(ElementType), sizeof(ElementType));
        return Index;
    }
    SizeType AddZeroed(SizeType Count)
    {
        const SizeType Index = AddUninitialized(Count);
        FMemory::Memzero((uint8*)AllocatorInstance.GetAllocation() + Index*sizeof(ElementType), Count*sizeof(ElementType));
        return Index;
    }
 
    [[nodiscard]] ElementType& AddZeroed_GetRef() UE_LIFETIMEBOUND
    {
        const SizeType Index = AddUninitialized();
        ElementType* Ptr = GetData() + Index;
        FMemory::Memzero(Ptr, sizeof(ElementType));
        return *Ptr;
    }
 
    SizeType AddDefaulted()
    {
        const SizeType Index = AddUninitialized();
        DefaultConstructItems<ElementType>((void*)((uint8*)AllocatorInstance.GetAllocation() + Index * sizeof(ElementType)), 1);
        return Index;
    }
    SizeType AddDefaulted(SizeType Count)
    {
        const SizeType Index = AddUninitialized(Count);
        DefaultConstructItems<ElementType>((void*)((uint8*)AllocatorInstance.GetAllocation() + Index * sizeof(ElementType)), Count);
        return Index;
    }
 
    [[nodiscard]] ElementType& AddDefaulted_GetRef() UE_LIFETIMEBOUND
    {
        const SizeType Index = AddUninitialized();
        ElementType* Ptr = GetData() + Index;
        DefaultConstructItems<ElementType>((void*)Ptr, 1);
        return *Ptr;
    }
 
#if !UE_DEPRECATE_MUTABLE_TOBJECTPTR
    template <
        typename AliasElementType = ElementType
        UE_REQUIRES(TIsContainerElementTypeReinterpretable_V<AliasElementType>)
    >
    [[nodiscard]] operator TArray<typename TContainerElementTypeCompatibility<AliasElementType>::ReinterpretType, AllocatorType>& ()
    {
        using ElementCompat = TContainerElementTypeCompatibility<ElementType>;
        ElementCompat::ReinterpretRangeContiguous(begin(), end(), Num());
        return *reinterpret_cast<TArray<typename ElementCompat::ReinterpretType>*>(this);
    }
#endif
 
    template <
        typename AliasElementType = ElementType
        UE_REQUIRES(TIsContainerElementTypeReinterpretable_V<AliasElementType>)
    >
    [[nodiscard]] operator const TArray<typename TContainerElementTypeCompatibility<AliasElementType>::ReinterpretType, AllocatorType>& () const
    {
        using ElementCompat = TContainerElementTypeCompatibility<ElementType>;
        ElementCompat::ReinterpretRangeContiguous(begin(), end(), Num());
        return *reinterpret_cast<const TArray<typename ElementCompat::ReinterpretType>*>(this);
    }
 
    template <
        typename AliasElementType = ElementType
        UE_REQUIRES(TIsContainerElementTypeCopyable_V<AliasElementType>)
    >
    TArray& operator=(TArray<typename TContainerElementTypeCompatibility<ElementType>::CopyFromOtherType, AllocatorType>&& Other)
    {
        TContainerElementTypeCompatibility<ElementType>::CopyingFromOtherType();
        DestructItems(GetData(), ArrayNum);
        MoveOrCopy(*this, Other, ArrayMax);
        return *this;
    }
 
    template <
        typename OtherAllocator,
        typename AliasElementType = ElementType
        UE_REQUIRES(TIsContainerElementTypeCopyable_V<AliasElementType>)
    >
    TArray& operator=(const TArray<typename TContainerElementTypeCompatibility<ElementType>::CopyFromOtherType, OtherAllocator>& Other)
    {
        TContainerElementTypeCompatibility<ElementType>::CopyingFromOtherType();
        DestructItems(GetData(), ArrayNum);
        CopyToEmpty(Other.GetData(), Other.Num(), ArrayMax);
        return *this;
    }
 
    template <
        typename OtherAllocator,
        typename AliasElementType = ElementType
        UE_REQUIRES(TIsContainerElementTypeCopyable_V<AliasElementType>)
    >
    SizeType Insert(const TArray<typename TContainerElementTypeCompatibility<ElementType>::CopyFromOtherType, OtherAllocator>& Items, const SizeType InIndex)
    {
        TContainerElementTypeCompatibility<ElementType>::CopyingFromOtherType();
 
        auto NumNewElements = Items.Num();
 
        InsertUninitializedImpl(InIndex, NumNewElements);
        ConstructItems<ElementType>((void*)(GetData() + InIndex), Items.GetData(), NumNewElements);
 
        return InIndex;
    }
 
    template <
        typename OtherAllocator,
        typename AliasElementType = ElementType
        UE_REQUIRES(TIsContainerElementTypeCopyable_V<AliasElementType>)
    >
    SizeType Insert(TArray<typename TContainerElementTypeCompatibility<ElementType>::CopyFromOtherType, OtherAllocator>&& Items, const SizeType InIndex)
    {
        check((const void*)this != (const void*)&Items);
        TContainerElementTypeCompatibility<ElementType>::CopyingFromOtherType();
 
        auto NumNewElements = Items.Num();
 
        InsertUninitializedImpl(InIndex, NumNewElements);
        RelocateConstructItems<ElementType>((void*)(GetData() + InIndex), Items.GetData(), NumNewElements);
        Items.ArrayNum = 0;
 
        Items.SlackTrackerNumChanged();
 
        return InIndex;
    }
 
    template <
        typename AliasElementType = ElementType
        UE_REQUIRES(TIsContainerElementTypeCopyable_V<AliasElementType>)
    >
    void Append(const typename TContainerElementTypeCompatibility<ElementType>::CopyFromOtherType* Ptr, SizeType Count)
    {
        check(Ptr != nullptr || Count == 0);
        TContainerElementTypeCompatibility<ElementType>::CopyingFromOtherType();
 
        SizeType Pos = AddUninitialized(Count);
        ConstructItems<ElementType>((void*)(GetData() + Pos), Ptr, Count);
    }
 
private:
 
    template <typename ArgsType>
    SizeType AddUniqueImpl(ArgsType&& Args)
    {
        SizeType Index;
        if (Find(Args, Index))
        {
            return Index;
        }
 
        return Add(Forward<ArgsType>(Args));
    }
 
public:
 
    UE_FORCEINLINE_HINT SizeType AddUnique(ElementType&& Item)
    {
        return AddUniqueImpl(MoveTempIfPossible(Item));
    }
 
    UE_FORCEINLINE_HINT SizeType AddUnique(const ElementType& Item)
    {
        return AddUniqueImpl(Item);
    }
 
    UE_FORCEINLINE_HINT void Reserve(SizeType Number)
    {
        checkSlow(Number >= 0);
        if (Number < 0)
        {
            // Cast to USizeType first to prevent sign extension on negative sizes, producing unusually large values.
            UE::Core::Private::OnInvalidArrayNum((unsigned long long)(USizeType)Number);
        }
        else if (Number > ArrayMax)
        {
            UE::Core::Private::ReallocTo<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                Number,
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
    }
 
    void Init(const ElementType& Element, SizeType Number)
    {
        Empty(Number);
        for (SizeType Index = 0; Index < Number; ++Index)
        {
            Add(Element);
        }
    }
 
    SizeType RemoveSingle(const ElementType& Item)
    {
        SizeType Index = Find(Item);
        if (Index == INDEX_NONE)
        {
            return 0;
        }
 
        auto* RemovePtr = GetData() + Index;
 
        // Destruct items that match the specified Item.
        DestructItems(RemovePtr, 1);
        RelocateConstructItems<ElementType>((void*)RemovePtr, RemovePtr + 1, ArrayNum - (Index + 1));
 
        // Update the array count
        --ArrayNum;
 
        SlackTrackerNumChanged();
 
        // Removed one item
        return 1;
    }
 
    SizeType Remove(const ElementType& Item)
    {
        CheckAddress(&Item);
 
        // Element is non-const to preserve compatibility with existing code with a non-const operator==() member function
        return RemoveAll([&Item](ElementType& Element) { return Element == Item; });
    }
 
    template <class PREDICATE_CLASS>
    SizeType RemoveAll(const PREDICATE_CLASS& Predicate)
    {
        const SizeType OriginalNum = ArrayNum;
        if (!OriginalNum)
        {
            return 0; // nothing to do, loop assumes one item so need to deal with this edge case here
        }
 
        ElementType* Data = GetData();
 
        SizeType WriteIndex = 0;
        SizeType ReadIndex = 0;
        bool bNotMatch = !::Invoke(Predicate, Data[ReadIndex]); // use a ! to guarantee it can't be anything other than zero or one
        do
        {
            SizeType RunStartIndex = ReadIndex++;
            while (ReadIndex < OriginalNum && bNotMatch == !::Invoke(Predicate, Data[ReadIndex]))
            {
                ReadIndex++;
            }
            SizeType RunLength = ReadIndex - RunStartIndex;
            checkSlow(RunLength > 0);
            if (bNotMatch)
            {
                // this was a non-matching run, we need to move it
                if (WriteIndex != RunStartIndex)
                {
                    RelocateConstructItems<ElementType>((void*)(Data + WriteIndex), Data + RunStartIndex, RunLength);
                }
                WriteIndex += RunLength;
            }
            else
            {
                // this was a matching run, delete it
                DestructItems(Data + RunStartIndex, RunLength);
            }
            bNotMatch = !bNotMatch;
        } while (ReadIndex < OriginalNum);
 
        ArrayNum = WriteIndex;
 
        SlackTrackerNumChanged();
 
        return OriginalNum - ArrayNum;
    }
 
    template <class PREDICATE_CLASS>
    SizeType RemoveAllSwap(const PREDICATE_CLASS& Predicate, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        bool bRemoved = false;
        const SizeType OriginalNum = ArrayNum;
        for (SizeType ItemIndex = 0; ItemIndex < Num();)
        {
            if (::Invoke(Predicate, (*this)[ItemIndex]))
            {
                bRemoved = true;
                RemoveAtSwap(ItemIndex, EAllowShrinking::No);
            }
            else
            {
                ++ItemIndex;
            }
        }
 
        if (bRemoved && AllowShrinking == EAllowShrinking::Yes)
        {
            UE::Core::Private::ReallocShrink<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
 
        return OriginalNum - ArrayNum;
    }
    template <class PREDICATE_CLASS>
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveAllSwap")
    UE_NODEBUG UE_FORCEINLINE_HINT SizeType RemoveAllSwap(const PREDICATE_CLASS& Predicate, bool bAllowShrinking)
    {
        return RemoveAllSwap(Predicate, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    SizeType RemoveSingleSwap(const ElementType& Item, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        SizeType Index = Find(Item);
        if (Index == INDEX_NONE)
        {
            return 0;
        }
 
        RemoveAtSwap(Index, 1, AllowShrinking);
 
        // Removed one item
        return 1;
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveSingleSwap")
    UE_NODEBUG UE_FORCEINLINE_HINT SizeType RemoveSingleSwap(const ElementType& Item, bool bAllowShrinking)
    {
        return RemoveSingleSwap(Item, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    SizeType RemoveSwap(const ElementType& Item, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        CheckAddress(&Item);
 
        const SizeType OriginalNum = ArrayNum;
        bool bRemoved = false;
        for (SizeType Index = 0; Index < ArrayNum; Index++)
        {
            if ((*this)[Index] == Item)
            {
                bRemoved = true;
                RemoveAtSwap(Index--, EAllowShrinking::No);
            }
        }
 
        if (bRemoved && AllowShrinking == EAllowShrinking::Yes)
        {
            UE::Core::Private::ReallocShrink<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
        }
 
        return OriginalNum - ArrayNum;
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveSwap")
    UE_NODEBUG UE_FORCEINLINE_HINT SizeType RemoveSwap(const ElementType& Item, bool bAllowShrinking)
    {
        return RemoveSwap(Item, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    UE_FORCEINLINE_HINT void SwapMemory(SizeType FirstIndexToSwap, SizeType SecondIndexToSwap)
    {
        ::Swap(
            *(ElementType*)((uint8*)AllocatorInstance.GetAllocation() + (sizeof(ElementType)*FirstIndexToSwap)),
            *(ElementType*)((uint8*)AllocatorInstance.GetAllocation() + (sizeof(ElementType)*SecondIndexToSwap))
        );
    }
 
    UE_FORCEINLINE_HINT void Swap(SizeType FirstIndexToSwap, SizeType SecondIndexToSwap)
    {
        check((FirstIndexToSwap >= 0) && (SecondIndexToSwap >= 0));
        check((ArrayNum > FirstIndexToSwap) && (ArrayNum > SecondIndexToSwap));
        if (FirstIndexToSwap != SecondIndexToSwap)
        {
            SwapMemory(FirstIndexToSwap, SecondIndexToSwap);
        }
    }
 
    template<typename SearchType>
    bool FindItemByClass(SearchType **Item = nullptr, SizeType *ItemIndex = nullptr, SizeType StartIndex = 0) const
    {
        UClass* SearchClass = SearchType::StaticClass();
        for (SizeType Idx = StartIndex; Idx < ArrayNum; Idx++)
        {
            if ((*this)[Idx] != nullptr && (*this)[Idx]->IsA(SearchClass))
            {
                if (Item != nullptr)
                {
                    *Item = (SearchType*)((*this)[Idx]);
                }
                if (ItemIndex != nullptr)
                {
                    *ItemIndex = Idx;
                }
                return true;
            }
        }
        return false;
    }
 
    // Iterators
    using TIterator      = TIndexedContainerIterator<      TArray,       ElementType, SizeType>;
    using TConstIterator = TIndexedContainerIterator<const TArray, const ElementType, SizeType>;
 
    UE_NODEBUG [[nodiscard]] TIterator CreateIterator()
    {
        return TIterator(*this);
    }
 
    UE_NODEBUG [[nodiscard]] TConstIterator CreateConstIterator() const
    {
        return TConstIterator(*this);
    }
 
    #if TARRAY_RANGED_FOR_CHECKS
        using RangedForIteratorType             = TCheckedPointerIterator<      ElementType, SizeType, false>;
        using RangedForConstIteratorType        = TCheckedPointerIterator<const ElementType, SizeType, false>;
        using RangedForReverseIteratorType      = TCheckedPointerIterator<      ElementType, SizeType, true>;
        using RangedForConstReverseIteratorType = TCheckedPointerIterator<const ElementType, SizeType, true>;
    #else
        using RangedForIteratorType             =                               ElementType*;
        using RangedForConstIteratorType        =                         const ElementType*;
        using RangedForReverseIteratorType      = TReversePointerIterator<      ElementType>;
        using RangedForConstReverseIteratorType = TReversePointerIterator<const ElementType>;
    #endif
 
public:
 
    #if TARRAY_RANGED_FOR_CHECKS
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForIteratorType             begin ()       { return RangedForIteratorType            (ArrayNum, GetData()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstIteratorType        begin () const { return RangedForConstIteratorType       (ArrayNum, GetData()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForIteratorType             end   ()       { return RangedForIteratorType            (ArrayNum, GetData() + Num()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstIteratorType        end   () const { return RangedForConstIteratorType       (ArrayNum, GetData() + Num()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForReverseIteratorType      rbegin()       { return RangedForReverseIteratorType     (ArrayNum, GetData() + Num()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstReverseIteratorType rbegin() const { return RangedForConstReverseIteratorType(ArrayNum, GetData() + Num()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForReverseIteratorType      rend  ()       { return RangedForReverseIteratorType     (ArrayNum, GetData()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstReverseIteratorType rend  () const { return RangedForConstReverseIteratorType(ArrayNum, GetData()); }
    #else
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForIteratorType             begin ()       { return                                   GetData(); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstIteratorType        begin () const { return                                   GetData(); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForIteratorType             end   ()       { return                                   GetData() + Num(); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstIteratorType        end   () const { return                                   GetData() + Num(); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForReverseIteratorType      rbegin()       { return RangedForReverseIteratorType     (GetData() + Num()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstReverseIteratorType rbegin() const { return RangedForConstReverseIteratorType(GetData() + Num()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForReverseIteratorType      rend  ()       { return RangedForReverseIteratorType     (GetData()); }
        [[nodiscard]] UE_NODEBUG UE_FORCEINLINE_HINT RangedForConstReverseIteratorType rend  () const { return RangedForConstReverseIteratorType(GetData()); }
    #endif
 
public:
 
    UE_NODEBUG void Sort()
    {
        Algo::Sort(*this, TDereferenceWrapper<ElementType, TLess<>>(TLess<>()));
    }
 
    template <class PREDICATE_CLASS>
    UE_NODEBUG void Sort(const PREDICATE_CLASS& Predicate)
    {
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        Algo::Sort(*this, PredicateWrapper);
    }
 
    UE_NODEBUG void StableSort()
    {
        Algo::StableSort(*this, TDereferenceWrapper<ElementType, TLess<>>(TLess<>()));
    }
 
    template <class PREDICATE_CLASS>
    UE_NODEBUG void StableSort(const PREDICATE_CLASS& Predicate)
    {
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        Algo::StableSort(*this, PredicateWrapper);
    }
 
#if defined(_MSC_VER) && !defined(__clang__)    // Relies on MSVC-specific lazy template instantiation to support arrays of incomplete types
private:
    [[nodiscard]] FORCENOINLINE const ElementType& DebugGet(SizeType Index) const
    {
        return GetData()[Index];
    }
#endif
 
private:
    template <typename OtherElementType, typename OtherSizeType>
    void CopyToEmpty(const OtherElementType* OtherData, OtherSizeType OtherNum, SizeType PrevMax)
    {
        SizeType NewNum = (SizeType)OtherNum;
        checkf((OtherSizeType)NewNum == OtherNum, TEXT("Invalid number of elements to add to this array type: %lld"), (long long)NewNum);
 
        ArrayNum = NewNum;
        if (OtherNum || PrevMax)
        {
            UE::Core::Private::ReallocForCopy<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                NewNum,
                PrevMax,
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
            ConstructItems<ElementType>((void*)GetData(), OtherData, OtherNum);
        }
        else
        {
            ArrayMax = AllocatorInstance.GetInitialCapacity();
        }
 
        SlackTrackerNumChanged();
    }
 
    template <typename OtherElementType, typename OtherSizeType>
    void CopyToEmptyWithSlack(const OtherElementType* OtherData, OtherSizeType OtherNum, SizeType PrevMax, SizeType ExtraSlack)
    {
        SizeType NewNum = (SizeType)OtherNum;
        checkf((OtherSizeType)NewNum == OtherNum, TEXT("Invalid number of elements to add to this array type: %lld"), (long long)NewNum);
 
        ArrayNum = NewNum;
        if (OtherNum || ExtraSlack || PrevMax)
        {
            USizeType NewMax = NewNum + ExtraSlack;
 
            // This should only happen when we've underflowed or overflowed SizeType
            if ((SizeType)NewMax < NewNum)
            {
                UE::Core::Private::OnInvalidArrayNum((unsigned long long)NewMax);
            }
 
            UE::Core::Private::ReallocForCopy<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                sizeof(ElementType),
                alignof(ElementType),
                NewNum + ExtraSlack,
                PrevMax,
                AllocatorInstance,
                ArrayNum,
                ArrayMax
            );
            ConstructItems<ElementType>((void*)GetData(), OtherData, OtherNum);
        }
        else
        {
            ArrayMax = AllocatorInstance.GetInitialCapacity();
        }
 
        SlackTrackerNumChanged();
    }
 
protected:
 
    template<typename ElementType, typename AllocatorType>
    friend class TIndirectArray;
 
    ElementAllocatorType AllocatorInstance;
    SizeType             ArrayNum;
    SizeType             ArrayMax;
 
public:
    void WriteMemoryImage(FMemoryImageWriter& Writer) const
    {
        if constexpr (TAllocatorTraits<AllocatorType>::SupportsFreezeMemoryImage && THasTypeLayout<ElementType>::Value)
        {
            this->AllocatorInstance.WriteMemoryImage(Writer, StaticGetTypeLayoutDesc<ElementType>(), this->ArrayNum);
            Writer.WriteBytes(this->ArrayNum);
            Writer.WriteBytes(this->ArrayNum);
        }
        else
        {
            // Writing non-freezable TArray is only supported for 64-bit target for now
            // Would need complete layout macros for all allocator types in order to properly write (empty) 32bit versions
            check(Writer.Is64BitTarget());
            Writer.WriteBytes(TArray());
        }
    }
 
    void CopyUnfrozen(const FMemoryUnfreezeContent& Context, void* Dst) const
    {
        if constexpr (TAllocatorTraits<AllocatorType>::SupportsFreezeMemoryImage && THasTypeLayout<ElementType>::Value)
        {
            TArray* DstArray = ::new(Dst) TArray();
            DstArray->SetNumZeroed(this->ArrayNum);
            this->AllocatorInstance.CopyUnfrozen(Context, StaticGetTypeLayoutDesc<ElementType>(), this->ArrayNum, DstArray->GetData());
        }
        else
        {
            ::new(Dst) TArray();
        }
    }
 
    static void AppendHash(const FPlatformTypeLayoutParameters& LayoutParams, FSHA1& Hasher)
    {
        if constexpr (TAllocatorTraits<AllocatorType>::SupportsFreezeMemoryImage && THasTypeLayout<ElementType>::Value)
        {
            Freeze::AppendHash(StaticGetTypeLayoutDesc<ElementType>(), LayoutParams, Hasher);
        }
    }
 
    void ToString(const FPlatformTypeLayoutParameters& LayoutParams, FMemoryToStringContext& OutContext) const
    {
        if constexpr (TAllocatorTraits<AllocatorType>::SupportsFreezeMemoryImage && THasTypeLayout<ElementType>::Value)
        {
            this->AllocatorInstance.ToString(StaticGetTypeLayoutDesc<ElementType>(), this->ArrayNum, this->ArrayMax, LayoutParams, OutContext);
        }
    }
 
public:
    template <class PREDICATE_CLASS>
    UE_NODEBUG UE_FORCEINLINE_HINT void Heapify(const PREDICATE_CLASS& Predicate)
    {
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        Algo::Heapify(*this, PredicateWrapper);
    }
 
    UE_NODEBUG void Heapify()
    {
        Heapify(TLess<ElementType>());
    }
 
    template <class PREDICATE_CLASS>
    SizeType HeapPush(ElementType&& InItem, const PREDICATE_CLASS& Predicate)
    {
        // Add at the end, then sift up
        Add(MoveTempIfPossible(InItem));
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        SizeType Result = AlgoImpl::HeapSiftUp(GetData(), (SizeType)0, Num() - 1, FIdentityFunctor(), PredicateWrapper);
 
        return Result;
    }
 
    template <class PREDICATE_CLASS>
    SizeType HeapPush(const ElementType& InItem, const PREDICATE_CLASS& Predicate)
    {
        // Add at the end, then sift up
        Add(InItem);
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        SizeType Result = AlgoImpl::HeapSiftUp(GetData(), (SizeType)0, Num() - 1, FIdentityFunctor(), PredicateWrapper);
 
        return Result;
    }
 
    UE_NODEBUG SizeType HeapPush(ElementType&& InItem)
    {
        return HeapPush(MoveTempIfPossible(InItem), TLess<ElementType>());
    }
 
    UE_NODEBUG SizeType HeapPush(const ElementType& InItem)
    {
        return HeapPush(InItem, TLess<ElementType>());
    }
 
    template <class PREDICATE_CLASS>
    void HeapPop(ElementType& OutItem, const PREDICATE_CLASS& Predicate, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        OutItem = MoveTemp((*this)[0]);
        RemoveAtSwap(0, 1, AllowShrinking);
 
        TDereferenceWrapper< ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        AlgoImpl::HeapSiftDown(GetData(), (SizeType)0, Num(), FIdentityFunctor(), PredicateWrapper);
    }
    template <class PREDICATE_CLASS>
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("HeapPop")
    UE_NODEBUG UE_FORCEINLINE_HINT void HeapPop(ElementType& OutItem, const PREDICATE_CLASS& Predicate, bool bAllowShrinking)
    {
        HeapPop(OutItem, Predicate, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    UE_NODEBUG void HeapPop(ElementType& OutItem, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        HeapPop(OutItem, TLess<ElementType>(), AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("HeapPop")
    UE_NODEBUG UE_FORCEINLINE_HINT void HeapPop(ElementType& OutItem, bool bAllowShrinking)
    {
        HeapPop(OutItem, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    template <class PREDICATE_CLASS>
    UE_NODEBUG void VerifyHeap(const PREDICATE_CLASS& Predicate)
    {
        check(Algo::IsHeap(*this, Predicate));
    }
 
    template <class PREDICATE_CLASS>
    void HeapPopDiscard(const PREDICATE_CLASS& Predicate, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        RemoveAtSwap(0, 1, AllowShrinking);
        TDereferenceWrapper< ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        AlgoImpl::HeapSiftDown(GetData(), (SizeType)0, Num(), FIdentityFunctor(), PredicateWrapper);
    }
    template <class PREDICATE_CLASS>
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("HeapPopDiscard")
    UE_NODEBUG UE_FORCEINLINE_HINT void HeapPopDiscard(const PREDICATE_CLASS& Predicate, bool bAllowShrinking)
    {
        HeapPopDiscard(Predicate, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    UE_NODEBUG void HeapPopDiscard(EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        HeapPopDiscard(TLess<ElementType>(), AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("HeapPopDiscard")
    UE_NODEBUG UE_FORCEINLINE_HINT void HeapPopDiscard(bool bAllowShrinking)
    {
        HeapPopDiscard(TLess<ElementType>(), bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    UE_NODEBUG [[nodiscard]] const ElementType& HeapTop() const UE_LIFETIMEBOUND
    {
        return (*this)[0];
    }
 
    UE_NODEBUG [[nodiscard]] ElementType& HeapTop() UE_LIFETIMEBOUND
    {
        return (*this)[0];
    }
 
    template <class PREDICATE_CLASS>
    void HeapRemoveAt(SizeType Index, const PREDICATE_CLASS& Predicate, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        RemoveAtSwap(Index, 1, AllowShrinking);
 
        TDereferenceWrapper< ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        AlgoImpl::HeapSiftDown(GetData(), Index, Num(), FIdentityFunctor(), PredicateWrapper);
        AlgoImpl::HeapSiftUp(GetData(), (SizeType)0, FPlatformMath::Min(Index, Num() - 1), FIdentityFunctor(), PredicateWrapper);
    }
    template <class PREDICATE_CLASS>
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("HeapRemoveAt")
    UE_NODEBUG void HeapRemoveAt(SizeType Index, const PREDICATE_CLASS& Predicate, bool bAllowShrinking)
    {
        HeapRemoveAt(Index, Predicate, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    UE_NODEBUG void HeapRemoveAt(SizeType Index, EAllowShrinking AllowShrinking = UE::Core::Private::AllowShrinkingByDefault<AllocatorType>())
    {
        HeapRemoveAt(Index, TLess< ElementType >(), AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("HeapRemoveAt")
    UE_NODEBUG UE_FORCEINLINE_HINT void HeapRemoveAt(SizeType Index, bool bAllowShrinking)
    {
        HeapRemoveAt(Index, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    template <class PREDICATE_CLASS>
    UE_NODEBUG void HeapSort(const PREDICATE_CLASS& Predicate)
    {
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        Algo::HeapSort(*this, PredicateWrapper);
    }
 
    UE_NODEBUG void HeapSort()
    {
        HeapSort(TLess<ElementType>());
    }
 
    UE_NODEBUG [[nodiscard]] const ElementAllocatorType& GetAllocatorInstance() const
    {
        return AllocatorInstance;
    }
    UE_NODEBUG [[nodiscard]] ElementAllocatorType& GetAllocatorInstance()
    {
        return AllocatorInstance;
    }
 
    friend struct TArrayPrivateFriend;
};
 
 
namespace Freeze
{
    template<typename T, typename AllocatorType>
    UE_NODEBUG void IntrinsicWriteMemoryImage(FMemoryImageWriter& Writer, const TArray<T, AllocatorType>& Object, const FTypeLayoutDesc&)
    {
        Object.WriteMemoryImage(Writer);
    }
 
    template<typename T, typename AllocatorType>
    UE_NODEBUG [[nodiscard]] uint32 IntrinsicUnfrozenCopy(const FMemoryUnfreezeContent& Context, const TArray<T, AllocatorType>& Object, void* OutDst)
    {
        Object.CopyUnfrozen(Context, OutDst);
        return sizeof(Object);
    }
 
    template<typename T, typename AllocatorType>
    UE_NODEBUG [[nodiscard]] uint32 IntrinsicAppendHash(const TArray<T, AllocatorType>* DummyObject, const FTypeLayoutDesc& TypeDesc, const FPlatformTypeLayoutParameters& LayoutParams, FSHA1& Hasher)
    {
        return AppendHashForNameAndSize(TypeDesc.Name, sizeof(TArray<T, AllocatorType>), Hasher);
    }
 
    template<typename T, typename AllocatorType>
    UE_NODEBUG [[nodiscard]] uint32 IntrinsicGetTargetAlignment(const TArray<T, AllocatorType>* DummyObject, const FTypeLayoutDesc& TypeDesc, const FPlatformTypeLayoutParameters& LayoutParams)
    {
        // Assume alignment of array is drive by pointer
        return FMath::Min(8u, LayoutParams.MaxFieldAlignment);
    }
 
    template<typename T, typename AllocatorType>
    UE_NODEBUG void IntrinsicToString(const TArray<T, AllocatorType>& Object, const FTypeLayoutDesc& TypeDesc, const FPlatformTypeLayoutParameters& LayoutParams, FMemoryToStringContext& OutContext)
    {
        Object.ToString(LayoutParams, OutContext);
    }
}
 
DECLARE_TEMPLATE_INTRINSIC_TYPE_LAYOUT((template <typename T, typename AllocatorType>), (TArray<T, AllocatorType>));
 
template <typename InElementType, typename AllocatorType>
struct TIsZeroConstructType<TArray<InElementType, AllocatorType>>
{
    enum { Value = TAllocatorTraits<AllocatorType>::IsZeroConstruct };
};
 
template <typename T, typename AllocatorType>
struct TIsContiguousContainer<TArray<T, AllocatorType>>
{
    enum { Value = true };
};
 
template <typename T> constexpr bool TIsTArray_V = false;
 
template <typename InElementType, typename InAllocatorType> constexpr bool TIsTArray_V<               TArray<InElementType, InAllocatorType>> = true;
template <typename InElementType, typename InAllocatorType> constexpr bool TIsTArray_V<const          TArray<InElementType, InAllocatorType>> = true;
template <typename InElementType, typename InAllocatorType> constexpr bool TIsTArray_V<      volatile TArray<InElementType, InAllocatorType>> = true;
template <typename InElementType, typename InAllocatorType> constexpr bool TIsTArray_V<const volatile TArray<InElementType, InAllocatorType>> = true;
 
template <typename T>
struct TIsTArray
{
    enum { Value = TIsTArray_V<T> };
};
 
 
//
// Array operator news.
//
template <typename T,typename AllocatorType>
UE_NODEBUG void* operator new(size_t Size, TArray<T, AllocatorType>& Array)
{
    check(Size == sizeof(T));
    const auto Index = Array.AddUninitialized();
    return &Array[Index];
}
template <typename T,typename AllocatorType>
UE_NODEBUG void* operator new(size_t Size, TArray<T,AllocatorType>& Array, typename TArray<T, AllocatorType>::SizeType Index)
{
    check(Size == sizeof(T));
    Array.InsertUninitialized(Index);
    return &Array[Index];
}
 
struct TArrayPrivateFriend
{
    template<typename ElementType, typename AllocatorType>
    static FArchive& Serialize(FArchive& Ar, TArray<ElementType, AllocatorType>& A)
    {
        A.CountBytes(Ar);
 
        // For net archives, limit serialization to 16MB, to protect against excessive allocation
        using SizeType = typename AllocatorType::SizeType;
        constexpr SizeType MaxNetArraySerialize = (16 * 1024 * 1024) / sizeof(ElementType);
        SizeType SerializeNum = Ar.IsLoading() ? 0 : A.ArrayNum;
 
        Ar << SerializeNum;
 
        if (SerializeNum == 0)
        {
            // if we are loading, then we have to reset the size to 0, in case it isn't currently 0
            if (Ar.IsLoading())
            {
                A.Empty();
            }
            return Ar;
        }
 
        if (Ar.IsError() || SerializeNum < 0 || !ensure(!Ar.IsNetArchive() || SerializeNum <= MaxNetArraySerialize))
        {
            Ar.SetError();
            return Ar;
        }
 
        // if we don't need to perform per-item serialization, just read it in bulk
        if constexpr (sizeof(ElementType) == 1 || TCanBulkSerialize<ElementType>::Value)
        {
            A.ArrayNum = SerializeNum;
 
            // Serialize simple bytes which require no construction or destruction.
            if ((A.ArrayNum || A.ArrayMax) && Ar.IsLoading())
            {
                UE::Core::Private::ReallocForCopy<UE::Core::Private::GetAllocatorFlags<AllocatorType>()>(
                    sizeof(ElementType),
                    alignof(ElementType),
                    A.ArrayNum,
                    A.ArrayMax,
                    A.AllocatorInstance,
                    A.ArrayNum,
                    A.ArrayMax
                );
            }
 
            if constexpr (TIsUECoreVariant<ElementType, double>::Value)
            {
                if (Ar.IsLoading() && Ar.UEVer() < EUnrealEngineObjectUE5Version::LARGE_WORLD_COORDINATES)
                {
                    // Per item serialization is required for core variant types loaded from pre LWC archives, to enable conversion from float to double.
                    A.Empty(SerializeNum);
                    for (SizeType i = 0; i < SerializeNum; i++)
                    {
                        Ar << A.AddDefaulted_GetRef();
                    }
                }
                else
                {
                    Ar.Serialize(A.GetData(), A.Num() * sizeof(ElementType));
                }
            }
            else
            {
                Ar.Serialize(A.GetData(), A.Num() * sizeof(ElementType));
            }
 
        }
        else if (Ar.IsLoading())
        {
            // Required for resetting ArrayNum
            A.Empty(SerializeNum);
 
            for (SizeType i=0; i<SerializeNum; i++)
            {
                Ar << A.AddDefaulted_GetRef();
            }
        }
        else
        {
            A.ArrayNum = SerializeNum;
 
            for (SizeType i=0; i<A.ArrayNum; i++)
            {
                Ar << A[i];
            }
        }
 
        A.SlackTrackerNumChanged();
 
        return Ar;
    }
};
 
 
template<typename ElementType, typename AllocatorType>
UE_NODEBUG FArchive& operator<<(FArchive& Ar, TArray<ElementType, AllocatorType>& A)
{
    return TArrayPrivateFriend::Serialize(Ar, A);
}
 
template<typename InElementType, typename InAllocatorType>
[[nodiscard]] uint32 GetTypeHash(const TArray<InElementType, InAllocatorType>& A)
{
    uint32 Hash = 0;
    for (const InElementType& V : A)
    {
        Hash = HashCombineFast(Hash, GetTypeHash(V));
    }
    return Hash;
}
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "Templates/IsSigned.h"
#include "Templates/AndOrNot.h"
#include "Templates/IsConstructible.h"
#include "Templates/MakeUnsigned.h"
#endif