StructArrayView.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/Class.h"
#include "StructUtils.h"
#include "StructUtils/StructView.h"
#include <type_traits>
 
 
struct FStructArrayView
{
    FStructArrayView() = default;
 
    template<typename T>
    explicit FStructArrayView(TArray<T>& InArray)
        : DataPtr(InArray.GetData())
        , ScriptStruct(StaticStruct<std::remove_reference_t<T>>())
        , ElementSize(sizeof(T))
        , ArrayNum(InArray.Num())
    {}
 
    template<typename T>
    explicit FStructArrayView(TArrayView<T> InArrayView)
        : DataPtr(InArrayView.GetData())
        , ScriptStruct(StaticStruct<std::remove_reference_t<T>>())
        , ElementSize(sizeof(T))
        , ArrayNum(InArrayView.Num())
    {}
 
    FStructArrayView(const UScriptStruct* InScriptStruct, void* InData, const uint32 InElementSize, const int32 InCount)
        : DataPtr(InData)
        , ScriptStruct(InScriptStruct)
        , ElementSize(InElementSize)
        , ArrayNum(InCount)
    {
        check((InData == nullptr) || ((InScriptStruct != nullptr) && (InElementSize > 0) && (InCount >= 0)));
        check((InData != nullptr) || ((InScriptStruct == nullptr) && (InElementSize == 0) && (InCount == 0)));
    }
 
    FStructArrayView(const UScriptStruct& InScriptStruct, void* InData, const int32 InCount)
        : DataPtr(InData)
        , ScriptStruct(&InScriptStruct)
        , ElementSize(InScriptStruct.GetStructureSize())
        , ArrayNum(InCount)
    {
        check(InCount >= 0);
        check(InData != nullptr || InCount == 0);
    }
 
    UE_DEPRECATED(5.3, "Use constructor that takes a reference instead")
    FStructArrayView(const UScriptStruct* InScriptStruct, void* InData, const int32 InCount)
        : DataPtr(InData)
        , ScriptStruct(InScriptStruct)
        , ElementSize(InScriptStruct->GetStructureSize())
        , ArrayNum(InCount)
    {
        check(InScriptStruct);
        check(InCount >= 0);
        check(InData != nullptr || InCount == 0);
    }
 
    void CheckInvariants() const
    {
        checkSlow(ArrayNum >= 0);
    }
 
    void RangeCheck(int32 Index) const
    {
        checkf((Index >= 0) & (Index < ArrayNum), TEXT("Array index out of bounds: %d from an array of size %d"), Index, ArrayNum);
    }
 
    void SliceRangeCheck(const int32 Index, const int32 InNum) const
    {
        checkf(Index >= 0, TEXT("Invalid index (%d)"), Index);
        checkf(InNum >= 0, TEXT("Invalid count (%d)"), InNum);
        checkf(Index + InNum <= ArrayNum, TEXT("Range (index: %d, count: %d) lies outside the view of %d elements"), Index, InNum, ArrayNum);
    }
 
    bool IsValidIndex(const int32 Index) const
    {
        return (Index >= 0) && (Index < ArrayNum);
    }
 
    bool IsEmpty() const
    {
        return ArrayNum == 0;
    }
 
    void* GetData() const
    {
        return DataPtr;
    }
 
    void* GetDataAt(const int32 Index) const 
    { 
        RangeCheck(Index);
        return (uint8*)DataPtr + ((SIZE_T)Index * ElementSize); 
    }
 
    UE_DEPRECATED(5.3, "Use GetDataAt() instead")
    void* GetMutableDataAt(const int32 Index) const { return GetDataAt(Index); }
 
    UE_FORCEINLINE_HINT uint32 GetTypeSize() const
    {
        return ElementSize;
    }
 
    UE_DEPRECATED(5.3, "Removed to bring in to line with ArrayView, use GetTypeSize() instead")
    SIZE_T GetElementSize() const { return ElementSize; }
 
    int32 Num() const { return ArrayNum; }
 
    UE_DEPRECATED(5.3, "Use GetScriptStruct() instead")
    const UScriptStruct& GetElementType() const { check(ScriptStruct); return *ScriptStruct; }
 
    UE_DEPRECATED(5.3, "Use GetScriptStruct() instead")
    const UScriptStruct& GetFragmentType() const { check(ScriptStruct);  return *ScriptStruct; }
    
    const UScriptStruct* GetScriptStruct() const { return ScriptStruct; }
 
    template<typename T>
    T* GetPtrAt(const int32 Index) const
    {
        return UE::StructUtils::GetStructPtr<T>(ScriptStruct, GetDataAt(Index)); // GetDataAt() calls RangeCheck().
    }
 
    template<typename T>
    T& GetAt(const int32 Index) const
    {
        return UE::StructUtils::GetStructRef<T>(ScriptStruct, GetDataAt(Index)); // GetDataAt() calls RangeCheck().
    }
 
    template<typename T>
    UE_DEPRECATED(5.3, "Use GetAt() instead!")
    const T& GetElementAt(const int32 Index) const
    {
        return *((T*)GetDataAt(Index));
    }
 
    template<typename T>
    UE_DEPRECATED(5.3, "Use GetAt() instead!")
    const T& GetElementAtChecked(const int32 Index) const
    {
        check(TBaseStructure<T>::Get() == &ScriptStruct);
        return *((T*)GetDataAt(Index));
    }
 
    template<typename T>
    UE_DEPRECATED(5.3, "Use GetAt() instead!")
    T& GetMutableElementAt(const int32 Index) const
    {
        return *((T*)GetDataAt(Index));
    }
 
    template<typename T>
    UE_DEPRECATED(5.3, "Use GetAt() instead!")
    T& GetMutableElementAtChecked(const int32 Index) const
    {
        check(TBaseStructure<T>::Get() == &ScriptStruct);
        return *((T*)GetDataAt(Index));
    }
 
    FStructView operator[](const int32 Index) const
    {
        return FStructView(ScriptStruct, (uint8*)GetDataAt(Index)); // GetDataAt() calls RangeCheck().
    }
 
    template<typename T>
    T& Last(const int32 IndexFromTheEnd = 0) const
    {
        return GetAt<T>(ArrayNum - IndexFromTheEnd - 1);
    }
 
    [[nodiscard]] FStructArrayView Slice(const int32 Index, const int32 InNum) const
    {
        SliceRangeCheck(Index, InNum);
        return FStructArrayView(ScriptStruct, GetDataAt(Index), ElementSize, InNum);
    }
 
    [[nodiscard]] FStructArrayView Left(const int32 Count) const
    {
        return FStructArrayView(ScriptStruct, DataPtr, ElementSize, FMath::Clamp(Count, 0, ArrayNum));
    }
 
    [[nodiscard]] FStructArrayView LeftChop(const int32 Count) const
    {
        return FStructArrayView(ScriptStruct, DataPtr, ElementSize, FMath::Clamp(ArrayNum - Count, 0, ArrayNum));
    }
 
    [[nodiscard]] FStructArrayView Right(const int32 Count) const
    {
        const int32 OutLen = FMath::Clamp(Count, 0, ArrayNum);
        return FStructArrayView(ScriptStruct, GetDataAt(ArrayNum - OutLen), ElementSize, OutLen);
    }
 
    [[nodiscard]] FStructArrayView RightChop(const int32 Count) const
    {
        const int32 OutLen = FMath::Clamp(ArrayNum - Count, 0, ArrayNum);
        return FStructArrayView(ScriptStruct, GetDataAt(ArrayNum - OutLen), ElementSize, OutLen);
    }
 
    [[nodiscard]] FStructArrayView Mid(int32 Index, int32 Count = TNumericLimits<int32>::Max()) const
    {
        UE::StructUtils::CalcMidIndexAndCount(ArrayNum, Index, Count);
        return FStructArrayView(ScriptStruct, GetDataAt(Index), ElementSize, Count);;
    }
 
    void LeftInline(const int32 Count)
    {
        *this = Left(Count);
    }
 
    void LeftChopInline(const int32 Count)
    {
        *this = LeftChop(Count);
    }
 
    void RightInline(const int32 Count)
    {
        *this = Right(Count);
    }
 
    void RightChopInline(const int32 Count)
    {
        *this = RightChop(Count);
    }
 
    inline void MidInline(const int32 Position, const int32 Count = TNumericLimits<int32>::Max())
    {
        *this = Mid(Position, Count);
    }
 
    struct FIterator
    {
        FIterator(const FStructArrayView& InOwner, int32 InIndex)
            : Owner(&InOwner)
            , Index(InIndex)
        {}
 
        FIterator& operator++()
        {
            ++Index;
            return *this;
        }
 
        FStructView operator*() const
        {
            return (*Owner)[Index];
        }
 
        inline bool operator == (const FIterator& Other) const
        {
            return Owner == Other.Owner
                && Index == Other.Index;
        }
 
        UE_FORCEINLINE_HINT bool operator != (const FIterator& Other) const
        {
            return !(*this == Other);
        }
 
    private:
        const FStructArrayView* Owner = nullptr;
        int32 Index = INDEX_NONE;
    };
 
    UE_FORCEINLINE_HINT FIterator begin() const { return FIterator(*this, 0); }
    UE_FORCEINLINE_HINT FIterator end() const { return FIterator(*this, Num()); }
 
    UE_FORCEINLINE_HINT void Swap(const int32 Index1, const int32 Index2)
    {
        FMemory::Memswap(GetDataAt(Index1), GetDataAt(Index2), ElementSize); // GetDataAt() calls RangeCheck().
    }
 
private:
    void* DataPtr = nullptr;
    const UScriptStruct* ScriptStruct = nullptr;
    uint32 ElementSize = 0;
    int32 ArrayNum = 0;
};
 
 
struct FConstStructArrayView
{
    FConstStructArrayView() = default;
 
    template<typename T>
    explicit FConstStructArrayView(TArray<T>& InArray)
        : DataPtr(InArray.GetData())
        , ScriptStruct(StaticStruct<std::remove_reference_t<T>>())
        , ElementSize(sizeof(T))
        , ArrayNum(InArray.Num())
    {}
 
    template<typename T>
    explicit FConstStructArrayView(TArrayView<T> InArrayView)
        : DataPtr(InArrayView.GetData())
        , ScriptStruct(StaticStruct<std::remove_reference_t<T>>())
        , ElementSize(sizeof(T))
        , ArrayNum(InArrayView.Num())
    {}
 
    FConstStructArrayView(const FStructArrayView Src)
        : DataPtr(Src.GetData())
        , ScriptStruct(Src.GetScriptStruct())
        , ElementSize(Src.GetTypeSize())
        , ArrayNum(Src.Num())
    {}
 
    FConstStructArrayView(const UScriptStruct* InScriptStruct, const void* InData, const uint32 InElementSize, const int32 InCount)
        : DataPtr(InData)
        , ScriptStruct(InScriptStruct)
        , ElementSize(InElementSize)
        , ArrayNum(InCount)
    {
        check((InData == nullptr) || ((InScriptStruct != nullptr) && (InElementSize > 0) && (InCount >= 0)));
        check((InData != nullptr) || ((InScriptStruct == nullptr) && (InElementSize == 0) && (InCount == 0)));
    }
 
    FConstStructArrayView(const UScriptStruct& InScriptStruct, const void* InData, const int32 InCount)
        : DataPtr(InData)
        , ScriptStruct(&InScriptStruct)
        , ElementSize(InScriptStruct.GetStructureSize())
        , ArrayNum(InCount)
    {
        check(InCount >= 0);
        check(InData != nullptr || InCount == 0);
    }
 
    FConstStructArrayView& operator=(const FStructArrayView StructArrayView)
    {
        *this = FConstStructArrayView(StructArrayView);
        return *this;
    }
 
    void CheckInvariants() const
    {
        checkSlow(ArrayNum >= 0);
    }
 
    void RangeCheck(int32 Index) const
    {
        checkf((Index >= 0) & (Index < ArrayNum), TEXT("Array index out of bounds: %d from an array of size %d"), Index, ArrayNum);
    }
 
    inline void SliceRangeCheck(int32 Index, int32 InNum) const
    {
        checkf(Index >= 0, TEXT("Invalid index (%d)"), Index);
        checkf(InNum >= 0, TEXT("Invalid count (%d)"), InNum);
        checkf(Index + InNum <= ArrayNum, TEXT("Range (index: %d, count: %d) lies outside the view of %d elements"), Index, InNum, ArrayNum);
    }
 
    bool IsValidIndex(int32 Index) const
    {
        return (Index >= 0) && (Index < ArrayNum);
    }
 
    bool IsEmpty() const
    {
        return ArrayNum == 0;
    }
 
    const void* GetData() const
    {
        return DataPtr;
    }
 
    const void* GetDataAt(const int32 Index) const
    {
        RangeCheck(Index);
        return (uint8*)DataPtr + (SIZE_T)Index * ElementSize;
    }
 
    UE_FORCEINLINE_HINT uint32 GetTypeSize()
    {
        return ElementSize;
    }
 
    int32 Num() const { return ArrayNum; }
 
    const UScriptStruct* GetScriptStruct() const { return ScriptStruct; }
 
    template<typename T>
        requires (std::is_const_v<T>)
    constexpr T* GetPtrAt(const int32 Index) const
    {
        return UE::StructUtils::GetStructPtr<T>(ScriptStruct, GetDataAt(Index)); // GetDataAt() calls RangeCheck().
    }
 
    template<typename T>
        requires (std::is_const_v<T>)
    constexpr T& GetAt(const int32 Index) const
    {
        return UE::StructUtils::GetStructRef<T>(ScriptStruct, GetDataAt(Index)); // GetDataAt() calls RangeCheck().
    }
 
    FConstStructView operator[](int32 Index) const
    {
        return FConstStructView(ScriptStruct, (const uint8*)GetDataAt(Index)); // GetDataAt() calls RangeCheck().
    }
 
    template<typename T>
        requires (std::is_const_v<T>)
    constexpr T& Last(int32 IndexFromTheEnd = 0) const
    {
        return GetAt<T>(ArrayNum - IndexFromTheEnd - 1);
    }
 
    [[nodiscard]] FConstStructArrayView Slice(const int32 Index, const int32 InNum) const
    {
        SliceRangeCheck(Index, InNum);
        return FConstStructArrayView(ScriptStruct, GetDataAt(Index), ElementSize, InNum);
    }
 
    [[nodiscard]] FConstStructArrayView Left(const int32 Count) const
    {
        return FConstStructArrayView(ScriptStruct, DataPtr, ElementSize, FMath::Clamp(Count, 0, ArrayNum));
    }
 
    [[nodiscard]] FConstStructArrayView LeftChop(const int32 Count) const
    {
        return FConstStructArrayView(ScriptStruct, DataPtr, ElementSize, FMath::Clamp(ArrayNum - Count, 0, ArrayNum));
    }
 
    [[nodiscard]] FConstStructArrayView Right(const int32 Count) const
    {
        const int32 OutLen = FMath::Clamp(Count, 0, ArrayNum);
        return FConstStructArrayView(ScriptStruct, GetDataAt(ArrayNum - OutLen), ElementSize, OutLen);
    }
 
    [[nodiscard]] FConstStructArrayView RightChop(const int32 Count) const
    {
        const int32 OutLen = FMath::Clamp(ArrayNum - Count, 0, ArrayNum);
        return FConstStructArrayView(ScriptStruct, GetDataAt(ArrayNum - OutLen), ElementSize, OutLen);
    }
 
    [[nodiscard]] FConstStructArrayView Mid(int32 Index, int32 Count = TNumericLimits<int32>::Max()) const
    {
        UE::StructUtils::CalcMidIndexAndCount(ArrayNum, Index, Count);
        return FConstStructArrayView(ScriptStruct, GetDataAt(Index), ElementSize, Count);;
    }
 
    void LeftInline(const int32 Count)
    {
        *this = Left(Count);
    }
 
    void LeftChopInline(const int32 Count)
    {
        *this = LeftChop(Count);
    }
 
    void RightInline(const int32 Count)
    {
        *this = Right(Count);
    }
 
    void RightChopInline(const int32 Count)
    {
        *this = RightChop(Count);
    }
 
    inline void MidInline(const int32 Position, const int32 Count = TNumericLimits<int32>::Max())
    {
        *this = Mid(Position, Count);
    }
 
    struct FIterator
    {
        FIterator(const FConstStructArrayView& InOwner, int32 InIndex)
            : Owner(&InOwner)
            , Index(InIndex)
        {}
 
        FIterator& operator++()
        {
            ++Index;
            return *this;
        }
 
        FConstStructView operator*() const
        {
            return (*Owner)[Index];
        }
 
        inline bool operator == (const FIterator& Other) const
        {
            return Owner == Other.Owner
                && Index == Other.Index;
        }
 
        UE_FORCEINLINE_HINT bool operator != (const FIterator& Other) const
        {
            return !(*this == Other);
        }
 
    private:
        const FConstStructArrayView* Owner = nullptr;
        int32 Index = INDEX_NONE;
    };
 
    UE_FORCEINLINE_HINT FIterator begin() const { return FIterator(*this, 0); }
    UE_FORCEINLINE_HINT FIterator end() const { return FIterator(*this, Num()); }
 
private:
    const void* DataPtr = nullptr;
    const UScriptStruct* ScriptStruct = nullptr;
    uint32 ElementSize = 0;
    int32 ArrayNum = 0;
};