ArrayView.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/ContainersFwd.h" // IWYU pragma: export
#include "Misc/AssertionMacros.h"
#include "Misc/ReverseIterate.h"
#include "Misc/IntrusiveUnsetOptionalState.h"
#include "Misc/UEOps.h"
#include "Templates/Invoke.h"
#include "Templates/UnrealTypeTraits.h"
#include "Traits/ElementType.h"
#include "Containers/Array.h"
#include "Math/UnrealMathUtility.h"
#include <type_traits>
 
namespace UE::Core::ArrayView::Private
{
    template <typename T, typename ElementType>
    constexpr bool TIsCompatibleElementType_V =std::is_convertible_v<T**, ElementType* const*>;
 
    // Simply forwards to an unqualified GetData(), but can be called from within TArrayView
    // where GetData() is already a member and so hides any others.
    template <typename T>
    UE_FORCEINLINE_HINT constexpr auto GetDataHelper(T&& Arg) -> decltype(GetData(Forward<T>(Arg)))
    {
        return GetData(Forward<T>(Arg));
    }
 
    // Gets the data from the passed argument and proceeds to reinterpret the resulting elements
    template <typename T>
    inline decltype(auto) GetReinterpretedDataHelper(T&& Arg)
    {
        auto NaturalPtr = GetData(Forward<T>(Arg));
        using NaturalElementType = std::remove_pointer_t<decltype(NaturalPtr)>;
 
        auto Size = GetNum(Arg);
        auto EndPtr = NaturalPtr + Size;
        TContainerElementTypeCompatibility<NaturalElementType>::ReinterpretRangeContiguous(NaturalPtr, EndPtr, Size);
 
        return reinterpret_cast<typename TContainerElementTypeCompatibility<NaturalElementType>::ReinterpretType*>(NaturalPtr);
    }
 
    template <typename RangeType, typename ElementType>
    struct TIsCompatibleRangeType
    {
        static constexpr bool Value = TIsCompatibleElementType_V<std::remove_pointer_t<decltype(GetData(DeclVal<RangeType&>()))>, ElementType>;
 
        template <typename T>
        static constexpr decltype(auto) GetData(T&& Arg)
        {
            return UE::Core::ArrayView::Private::GetDataHelper(Forward<T>(Arg));
        }
    };
 
    template <typename RangeType, typename ElementType>
    struct TIsReinterpretableRangeType
    {
    private:
        using NaturalElementType = std::remove_pointer_t<decltype(GetData(DeclVal<RangeType&>()))>;
        using TypeCompat = TContainerElementTypeCompatibility<NaturalElementType>;
 
    public:
        static constexpr bool Value = 
            !std::is_same_v<typename TypeCompat::ReinterpretType, NaturalElementType>
            &&
            TIsCompatibleElementType_V<typename TypeCompat::ReinterpretType, ElementType>
            &&
            (!UE_DEPRECATE_MUTABLE_TOBJECTPTR
             || std::is_same_v<ElementType, std::remove_pointer_t<typename TypeCompat::ReinterpretType>* const>
             || std::is_same_v<ElementType, const std::remove_pointer_t<typename TypeCompat::ReinterpretType>* const>);
 
        template <typename T>
        static decltype(auto) GetData(T&& Arg)
        {
            return UE::Core::ArrayView::Private::GetReinterpretedDataHelper(Forward<T>(Arg));
        }
    };
}
 
template <typename T>                                  constexpr bool TIsTArrayView_V                                                       = false;
template <typename InElementType, typename InSizeType> constexpr bool TIsTArrayView_V<               TArrayView<InElementType, InSizeType>> = true;
template <typename InElementType, typename InSizeType> constexpr bool TIsTArrayView_V<      volatile TArrayView<InElementType, InSizeType>> = true;
template <typename InElementType, typename InSizeType> constexpr bool TIsTArrayView_V<const          TArrayView<InElementType, InSizeType>> = true;
template <typename InElementType, typename InSizeType> constexpr bool TIsTArrayView_V<const volatile TArrayView<InElementType, InSizeType>> = true;
 
template <typename T>
struct TIsTArrayView
{
    static constexpr bool Value = TIsTArrayView_V<T>;
    static constexpr bool value = TIsTArrayView_V<T>;
};
 
template<typename InElementType, typename InSizeType>
class TArrayView
{
public:
    using ElementType = InElementType;
    using SizeType = InSizeType;
 
    static_assert(std::is_signed_v<SizeType>, "TArrayView only supports signed index types");
 
    // Defaulted object behavior - we want compiler-generated functions rather than going through the generic range constructor.
    [[nodiscard]] constexpr TArrayView(const TArrayView&) = default;
    TArrayView& operator=(const TArrayView&) = default;
    ~TArrayView() = default;
 
    [[nodiscard]] constexpr TArrayView()
        : DataPtr(nullptr)
        , ArrayNum(0)
    {
    }
 
private:
    template <typename T>
    using TIsCompatibleRangeType = UE::Core::ArrayView::Private::TIsCompatibleRangeType<T, ElementType>;
 
    template <typename T>
    using TIsReinterpretableRangeType = UE::Core::ArrayView::Private::TIsReinterpretableRangeType<T, ElementType>;
 
public:
    template <
        typename OtherRangeType,
        typename CVUnqualifiedOtherRangeType = std::remove_cv_t<std::remove_reference_t<OtherRangeType>>
        UE_REQUIRES(
            TAnd<
                TIsContiguousContainer<CVUnqualifiedOtherRangeType>,
                TOr<
                    TIsCompatibleRangeType<OtherRangeType>,
                    TIsReinterpretableRangeType<OtherRangeType>
                >
            >::Value &&
            TIsTArrayView_V<CVUnqualifiedOtherRangeType> &&
            !std::is_same_v<CVUnqualifiedOtherRangeType, TArrayView>
        )
    >
    [[nodiscard]] constexpr TArrayView(OtherRangeType&& Other)
        : DataPtr(std::conditional_t<
                        TIsCompatibleRangeType<OtherRangeType>::Value,
                        TIsCompatibleRangeType<OtherRangeType>,
                        TIsReinterpretableRangeType<OtherRangeType>
                    >::GetData(Forward<OtherRangeType>(Other)))
    {
        const auto InCount = GetNum(Forward<OtherRangeType>(Other));
        using InCountType = decltype(InCount);
 
        // Unlike the other constructor, we don't need to check(InCount >= 0), because it's coming from a TArrayView which guarantees that
        if constexpr (sizeof(InCountType) > sizeof(SizeType) || (sizeof(InCountType) == sizeof(SizeType) && std::is_unsigned_v<InCountType>))
        {
            check(InCount <= static_cast<InCountType>(TNumericLimits<SizeType>::Max()));
        }
 
        ArrayNum = (SizeType)InCount;
    }
    template <
        typename OtherRangeType,
        typename CVUnqualifiedOtherRangeType = std::remove_cv_t<std::remove_reference_t<OtherRangeType>>
        UE_REQUIRES(
            TAnd<
                TIsContiguousContainer<CVUnqualifiedOtherRangeType>,
                TOr<
                    TIsCompatibleRangeType<OtherRangeType>,
                    TIsReinterpretableRangeType<OtherRangeType>
                >
            >::Value &&
            !TIsTArrayView_V<CVUnqualifiedOtherRangeType>
        )
    >
    [[nodiscard]] constexpr TArrayView(OtherRangeType&& Other UE_LIFETIMEBOUND)
        : DataPtr(std::conditional_t<
            TIsCompatibleRangeType<OtherRangeType>::Value,
            TIsCompatibleRangeType<OtherRangeType>,
            TIsReinterpretableRangeType<OtherRangeType>
        >::GetData(Forward<OtherRangeType>(Other)))
    {
        const auto InCount = GetNum(Forward<OtherRangeType>(Other));
        using InCountType = decltype(InCount);
        if constexpr (sizeof(InCountType) > sizeof(SizeType) || (sizeof(InCountType) == sizeof(SizeType) && std::is_unsigned_v<InCountType>))
        {
            check(InCount >= 0 && InCount <= static_cast<InCountType>(TNumericLimits<SizeType>::Max()));
        }
        else
        {
            check(InCount >= 0);
        }
        ArrayNum = (SizeType)InCount;
    }
 
    template <
        typename OtherElementType
        UE_REQUIRES(UE::Core::ArrayView::Private::TIsCompatibleElementType_V<OtherElementType, ElementType>)
    >
    [[nodiscard]] constexpr TArrayView(OtherElementType* InData UE_LIFETIMEBOUND, SizeType InCount)
        : DataPtr(InData)
        , ArrayNum(InCount)
    {
        check(ArrayNum >= 0);
    }
 
    [[nodiscard]] constexpr TArrayView(std::initializer_list<ElementType> List UE_LIFETIMEBOUND)
        : DataPtr(UE::Core::ArrayView::Private::GetDataHelper(List))
        , ArrayNum(GetNum(List))
    {
        static_assert(std::is_const_v<ElementType>, "Only views of const elements can bind to initializer lists");
    }
 
    // Start - intrusive TOptional<TArrayView> state //
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = TArrayView;
 
    [[nodiscard]] explicit constexpr TArrayView(FIntrusiveUnsetOptionalState)
        : DataPtr(nullptr)
        , ArrayNum(-1)
    {
    }
    [[nodiscard]] constexpr bool UEOpEquals(FIntrusiveUnsetOptionalState) const
    {
        return ArrayNum == -1;
    }
    // End - intrusive TOptional<TArrayView> state //
 
public:
 
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr ElementType* GetData() const
    {
        return DataPtr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT static constexpr size_t GetTypeSize()
    {
        return sizeof(ElementType);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT static constexpr size_t GetTypeAlignment()
    {
        return alignof(ElementType);
    }
 
    UE_FORCEINLINE_HINT constexpr void CheckInvariants() const
    {
        checkSlow(ArrayNum >= 0);
    }
 
    constexpr void RangeCheck(SizeType Index) const
    {
        CheckInvariants();
 
        checkf((Index >= 0) & (Index < ArrayNum),TEXT("Array index out of bounds: %lld from an array of size %lld"), (long long)Index, (long long)ArrayNum); // & for one branch
    }
 
    constexpr void SliceRangeCheck(SizeType Index, SizeType InNum) const
    {
        checkf(Index >= 0, TEXT("Invalid index (%lld)"), (long long)Index);
        checkf(InNum >= 0, TEXT("Invalid count (%lld)"), (long long)InNum);
        checkf(Index + InNum <= ArrayNum, TEXT("Range (index: %lld, count: %lld) lies outside the view of %lld elements"), (long long)Index, (long long)InNum, (long long)ArrayNum);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr bool IsValidIndex(SizeType Index) const
    {
        return (Index >= 0) && (Index < ArrayNum);
    }
 
    [[nodiscard]] constexpr bool IsEmpty() const
    {
        return ArrayNum == 0;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr SizeType Num() const
    {
        return ArrayNum;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr SIZE_T NumBytes() const
    {
        return static_cast<SIZE_T>(ArrayNum) * sizeof(ElementType);
    }
 
    [[nodiscard]] constexpr ElementType& operator[](SizeType Index) const
    {
        RangeCheck(Index);
        return GetData()[Index];
    }
 
    [[nodiscard]] constexpr ElementType& Last(SizeType IndexFromTheEnd = 0) const
    {
        RangeCheck(ArrayNum - IndexFromTheEnd - 1);
        return GetData()[ArrayNum - IndexFromTheEnd - 1];
    }
 
    [[nodiscard]] constexpr TArrayView Slice(SizeType Index, SizeType InNum) const
    {
        SliceRangeCheck(Index, InNum);
        return TArrayView(DataPtr + Index, InNum);
    }
 
    [[nodiscard]] constexpr TArrayView Left(SizeType Count) const
    {
        return TArrayView(DataPtr, FMath::Clamp(Count, (SizeType)0, ArrayNum));
    }
 
    [[nodiscard]] constexpr TArrayView LeftChop(SizeType Count) const
    {
        return TArrayView(DataPtr, FMath::Clamp(ArrayNum - Count, (SizeType)0, ArrayNum));
    }
 
    [[nodiscard]] constexpr TArrayView Right(SizeType Count) const
    {
        const SizeType OutLen = FMath::Clamp(Count, (SizeType)0, ArrayNum);
        return TArrayView(DataPtr + ArrayNum - OutLen, OutLen);
    }
 
    [[nodiscard]] constexpr TArrayView RightChop(SizeType Count) const
    {
        const SizeType OutLen = FMath::Clamp(ArrayNum - Count, (SizeType)0, ArrayNum);
        return TArrayView(DataPtr + ArrayNum - OutLen, OutLen);
    }
 
    [[nodiscard]] constexpr TArrayView Mid(SizeType Index, SizeType Count = TNumericLimits<SizeType>::Max()) const
    {
        ElementType* const CurrentStart  = GetData();
        const SizeType     CurrentLength = Num();
 
        // Clamp minimum index at the start of the range, adjusting the length down if necessary
        const SizeType NegativeIndexOffset = (Index < 0) ? Index : 0;
        Count += NegativeIndexOffset;
        Index -= NegativeIndexOffset;
 
        // Clamp maximum index at the end of the range
        Index = (Index > CurrentLength) ? CurrentLength : Index;
 
        // Clamp count between 0 and the distance to the end of the range
        Count = FMath::Clamp(Count, (SizeType)0, (CurrentLength - Index));
 
        TArrayView Result = TArrayView(CurrentStart + Index, Count);
        return Result;
    }
 
    constexpr void LeftInline(SizeType CharCount)
    {
        *this = Left(CharCount);
    }
 
    constexpr void LeftChopInline(SizeType CharCount)
    {
        *this = LeftChop(CharCount);
    }
 
    constexpr void RightInline(SizeType CharCount)
    {
        *this = Right(CharCount);
    }
 
    constexpr void RightChopInline(SizeType CharCount)
    {
        *this = RightChop(CharCount);
    }
 
    constexpr void MidInline(SizeType Position, SizeType CharCount = TNumericLimits<SizeType>::Max())
    {
        *this = Mid(Position, CharCount);
    }
 
    [[nodiscard]] constexpr bool Find(const ElementType& Item, SizeType& Index) const
    {
        Index = this->Find(Item);
        return Index != static_cast<SizeType>(INDEX_NONE);
    }
 
    [[nodiscard]] constexpr 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 static_cast<SizeType>(INDEX_NONE);
    }
 
    [[nodiscard]] constexpr bool FindLast(const ElementType& Item, SizeType& Index) const
    {
        Index = this->FindLast(Item);
        return Index != static_cast<SizeType>(INDEX_NONE);
    }
 
    [[nodiscard]] constexpr 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 static_cast<SizeType>(INDEX_NONE);
    }
 
    template <typename Predicate>
    [[nodiscard]] constexpr SizeType FindLastByPredicate(Predicate Pred, SizeType StartIndex) const
    {
        check(StartIndex >= 0 && StartIndex <= this->Num());
        for (const ElementType* RESTRICT Start = GetData(), *RESTRICT Data = Start + StartIndex; Data != Start; )
        {
            --Data;
            if (::Invoke(Pred, *Data))
            {
                return static_cast<SizeType>(Data - Start);
            }
        }
        return static_cast<SizeType>(INDEX_NONE);
    }
 
    template <typename Predicate>
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr SizeType FindLastByPredicate(Predicate Pred) const
    {
        return FindLastByPredicate(Pred, ArrayNum);
    }
 
    template <typename KeyType>
    [[nodiscard]] constexpr 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 static_cast<SizeType>(INDEX_NONE);
    }
 
    template <typename Predicate>
    [[nodiscard]] constexpr 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 static_cast<SizeType>(INDEX_NONE);
    }
 
    template <typename KeyType>
    [[nodiscard]] constexpr ElementType* FindByKey(const KeyType& Key) const
    {
        for (ElementType* RESTRICT Data = GetData(), *RESTRICT DataEnd = Data + ArrayNum; Data != DataEnd; ++Data)
        {
            if (*Data == Key)
            {
                return Data;
            }
        }
 
        return nullptr;
    }
 
    template <typename Predicate>
    [[nodiscard]] constexpr ElementType* FindByPredicate(Predicate Pred) const
    {
        for (ElementType* RESTRICT Data = GetData(), *RESTRICT DataEnd = Data + ArrayNum; Data != DataEnd; ++Data)
        {
            if (::Invoke(Pred, *Data))
            {
                return Data;
            }
        }
 
        return nullptr;
    }
 
    template <typename Predicate>
    [[nodiscard]] constexpr TArray<std::remove_const_t<ElementType>> FilterByPredicate(Predicate Pred) const
    {
        TArray<std::remove_const_t<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]] constexpr 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>
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr bool ContainsByPredicate(Predicate Pred) const
    {
        return FindByPredicate(Pred) != nullptr;
    }
 
public:
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr ElementType*                         begin () const { return GetData(); }
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr ElementType*                         end   () const { return GetData() + Num(); }
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr TReversePointerIterator<ElementType> rbegin() const { return TReversePointerIterator<ElementType>(GetData() + Num()); }
    [[nodiscard]] UE_FORCEINLINE_HINT constexpr TReversePointerIterator<ElementType> rend  () const { return TReversePointerIterator<ElementType>(GetData()); }
 
public:
    constexpr void Sort()
    {
        Algo::Sort(*this, TDereferenceWrapper<ElementType, TLess<>>(TLess<>()));
    }
 
    template <class PREDICATE_CLASS>
    constexpr void Sort(const PREDICATE_CLASS& Predicate)
    {
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        Algo::Sort(*this, PredicateWrapper);
    }
 
    constexpr void StableSort()
    {
        Algo::StableSort(*this, TDereferenceWrapper<ElementType, TLess<>>(TLess<>()));
    }
 
    template <class PREDICATE_CLASS>
    constexpr void StableSort(const PREDICATE_CLASS& Predicate)
    {
        TDereferenceWrapper<ElementType, PREDICATE_CLASS> PredicateWrapper(Predicate);
        Algo::StableSort(*this, PredicateWrapper);
    }
 
    // Comparison of array views to each other is not implemented because it
    // is not obvious whether the caller wants an exact match of the data
    // pointer and size, or to compare the objects being pointed to.
    template <typename OtherElementType, typename OtherSizeType>
    bool UEOpEquals(TArrayView<OtherElementType, OtherSizeType>) const = delete;
 
    template <typename RangeType>
        requires (std::is_convertible_v<decltype(UE::Core::ArrayView::Private::GetDataHelper(std::declval<RangeType&>())), const ElementType*>)
    [[nodiscard]] bool UEOpEquals(RangeType&& Rhs) const
    {
        auto Count = GetNum(Rhs);
        return Count == ArrayNum && CompareItems(DataPtr, UE::Core::ArrayView::Private::GetDataHelper(Rhs), Count);
    }
 
private:
    ElementType* DataPtr;
    SizeType ArrayNum;
};
 
template <typename T>
TArrayView(T*, int32) -> TArrayView<T>;
 
template <typename InElementType>
struct TIsZeroConstructType<TArrayView<InElementType>>
{
    enum { Value = true };
};
 
template <typename T, typename SizeType>
struct TIsContiguousContainer<TArrayView<T, SizeType>>
{
    enum { Value = true };
};
 
 
template <
    typename OtherRangeType,
    typename CVUnqualifiedOtherRangeType = std::remove_cv_t<std::remove_reference_t<OtherRangeType>>
    UE_REQUIRES(TIsContiguousContainer<CVUnqualifiedOtherRangeType>::Value && TIsTArrayView_V<CVUnqualifiedOtherRangeType>)
>
[[nodiscard]] constexpr auto MakeArrayView(OtherRangeType&& Other)
{
    return TArrayView<std::remove_pointer_t<decltype(GetData(DeclVal<OtherRangeType&>()))>>(Forward<OtherRangeType>(Other));
}
template <
    typename OtherRangeType,
    typename CVUnqualifiedOtherRangeType = std::remove_cv_t<std::remove_reference_t<OtherRangeType>>
    UE_REQUIRES(TIsContiguousContainer<CVUnqualifiedOtherRangeType>::Value && !TIsTArrayView_V<CVUnqualifiedOtherRangeType>)
>
[[nodiscard]] constexpr auto MakeArrayView(OtherRangeType&& Other UE_LIFETIMEBOUND)
{
    return TArrayView<std::remove_pointer_t<decltype(GetData(DeclVal<OtherRangeType&>()))>>(Forward<OtherRangeType>(Other));
}
 
template<typename ElementType>
[[nodiscard]] constexpr TArrayView<ElementType> MakeArrayView(ElementType* Pointer UE_LIFETIMEBOUND, int32 Size)
{
    return TArrayView<ElementType>(Pointer, Size);
}
 
template <typename ElementType>
[[nodiscard]] constexpr TArrayView<const ElementType> MakeArrayView(std::initializer_list<ElementType> List UE_LIFETIMEBOUND)
{
    return TArrayView<const ElementType>(List.begin(), List.size());
}
 
template <
    typename OtherRangeType,
    typename CVUnqualifiedOtherRangeType = std::remove_cv_t<std::remove_reference_t<OtherRangeType>>
    UE_REQUIRES(TIsContiguousContainer<CVUnqualifiedOtherRangeType>::Value && TIsTArrayView_V<CVUnqualifiedOtherRangeType>)
>
[[nodiscard]] constexpr auto MakeConstArrayView(OtherRangeType&& Other)
{
    return TArrayView<const std::remove_pointer_t<decltype(GetData(DeclVal<OtherRangeType&>()))>>(Forward<OtherRangeType>(Other));
}
template <
    typename OtherRangeType,
    typename CVUnqualifiedOtherRangeType = std::remove_cv_t<std::remove_reference_t<OtherRangeType>>
    UE_REQUIRES(TIsContiguousContainer<CVUnqualifiedOtherRangeType>::Value && !TIsTArrayView_V<CVUnqualifiedOtherRangeType>)
>
[[nodiscard]] constexpr auto MakeConstArrayView(OtherRangeType&& Other UE_LIFETIMEBOUND)
{
    return TArrayView<const std::remove_pointer_t<decltype(GetData(DeclVal<OtherRangeType&>()))>>(Forward<OtherRangeType>(Other));
}
 
template<typename ElementType>
[[nodiscard]] constexpr TArrayView<const ElementType> MakeConstArrayView(const ElementType* Pointer UE_LIFETIMEBOUND, int32 Size)
{
    return TArrayView<const ElementType>(Pointer, Size);
}
 
template <typename ElementType>
[[nodiscard]] constexpr TArrayView<const ElementType> MakeConstArrayView(std::initializer_list<ElementType> List UE_LIFETIMEBOUND)
{
    return TArrayView<const ElementType>(List.begin(), List.size());
}
 
 
template<typename InElementType, typename InAllocatorType>
template<typename OtherElementType, typename OtherSizeType>
[[nodiscard]] UE_FORCEINLINE_HINT TArray<InElementType, InAllocatorType>::TArray(const TArrayView<OtherElementType, OtherSizeType>& Other)
{
    CopyToEmpty(Other.GetData(), Other.Num(), 0);
}
 
template<typename InElementType, typename InAllocatorType>
template<typename OtherElementType, typename OtherSizeType>
inline TArray<InElementType, InAllocatorType>& TArray<InElementType, InAllocatorType>::operator=(const TArrayView<OtherElementType, OtherSizeType>& Other)
{
    DestructItems(GetData(), ArrayNum);
    CopyToEmpty(Other.GetData(), Other.Num(), ArrayMax);
    return *this;
}