InstancedStructContainer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "StructUtils/StructView.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptMacros.h"
 
#include "InstancedStructContainer.generated.h"
 
#define UE_API COREUOBJECT_API
 
struct FInstancedStruct;
class FReferenceCollector;
 
USTRUCT()
struct FInstancedStructContainer
{
    GENERATED_BODY()
 
private:
 
    struct FItem
    {
        FItem() = default;
        FItem(const UScriptStruct* InScriptStruct, const int32 InOffset) : ScriptStruct(InScriptStruct), Offset(InOffset) {}
 
        int32 GetStructureSize() const
        {
            return ScriptStruct != nullptr ? ScriptStruct->GetStructureSize() : 0;
        }
 
        int32 GetMinAlignment() const
        {
            return ScriptStruct != nullptr ? ScriptStruct->GetMinAlignment() : 1;
        }
 
        int32 GetEndOffset() const
        {
            return Offset + GetStructureSize();
        }
 
        TObjectPtr<const UScriptStruct> ScriptStruct = nullptr;
        int32 Offset = 0;
    };
 
public:
    
    static constexpr int32 OverheadPerItem = sizeof(FItem);
    
    UE_API FInstancedStructContainer();
    UE_API FInstancedStructContainer(const FInstancedStructContainer& InOther);
    UE_API FInstancedStructContainer(FInstancedStructContainer&& InOther);
    
    ~FInstancedStructContainer() { Empty(); }
 
    UE_API FInstancedStructContainer& operator=(const FInstancedStructContainer& InOther);
    UE_API FInstancedStructContainer& operator=(FInstancedStructContainer&& InOther);
    UE_API FInstancedStructContainer& operator=(TConstArrayView<FInstancedStruct> InItems);
    UE_API FInstancedStructContainer& operator=(TConstArrayView<FStructView> InItems);
    UE_API FInstancedStructContainer& operator=(TConstArrayView<FConstStructView> InItems);
 
    UE_API void Append(const FInstancedStructContainer& Other);
    UE_API void Append(TConstArrayView<FInstancedStruct> NewItemValues);
    UE_API void Append(TConstArrayView<FConstStructView> NewItemValues);
 
    UE_API void InsertAt(const int32 InsertAtIndex, const FInstancedStructContainer& Other);
    UE_API void InsertAt(const int32 InsertAtIndex, TConstArrayView<FInstancedStruct> ValuesToInsert);
    UE_API void InsertAt(const int32 InsertAtIndex, TConstArrayView<FStructView> ValuesToInsert);
    UE_API void InsertAt(const int32 InsertAtIndex, TConstArrayView<FConstStructView> ValuesToInsert);
 
    UE_API void RemoveAt(const int32 RemoveAtIndex, const int32 Count);
 
    UE_API void ReserveBytes(const int32 NumBytes, const int32 MinAlignment = DefaultMinAlignment);
    
    UE_API void SetNum(const int32 NewNum);
 
    int32 GetAllocatedMemory() const { return AllocatedSize; }
    
    UE_API void Reset();
 
    UE_API void Empty();
 
    bool IsValid() const { return NumItems > 0; }
 
    int32 Num() const { return NumItems; }
 
    bool IsValidIndex(const int32 Index) const { return Index >= 0 && Index < NumItems; }
 
    FConstStructView operator[](const int32 Index) const
    {
        check(IsValid() && IsValidIndex(Index));
        const FItem& Item = GetItem(Index);
        return FConstStructView(Item.ScriptStruct, Memory + Item.Offset);
    }
 
    FStructView operator[](const int32 Index)
    {
        check(IsValid() && IsValidIndex(Index));
        const FItem& Item = GetItem(Index);
        return FStructView(Item.ScriptStruct, Memory + Item.Offset);
    }
 
    template<typename T>
    struct TIterator
    {
        using StructViewType = std::conditional_t<std::is_const_v<T>, FConstStructView, FStructView>;
 
        StructViewType operator*()
        {
            const FItem& Item = Container.GetItem(Index);
            return StructViewType(Item.ScriptStruct, Container.Memory + Item.Offset);
        }
 
        TIterator& operator++()
        {
            Index++;
            return *this;
        }
 
        TIterator& operator--()
        {
            Index--;
            return *this;
        }
 
        bool operator!=(const TIterator& RHS) const
        {
            return Index != RHS.Index;
        }
 
        explicit operator bool() const
        {
            return Container.IsValidIndex(Index);
        }
 
        int32 GetIndex() const
        {
            return Index;
        }
 
        void RemoveCurrent()
        {
            static_assert(!std::is_const_v<T>, "Cannot remove on const container.");
            Container.RemoveAt(Index, 1);
            Index--;
        }
        
    private:
        explicit TIterator(T& InContainer, const int32 InIndex = 0)
            : Container(InContainer)
            , Index(InIndex)
        {
        }
 
        T& Container;
        int32 Index = 0;
 
        friend FInstancedStructContainer;
    };
 
    using FIterator = TIterator<FInstancedStructContainer>;
    using FConstIterator = TIterator<const FInstancedStructContainer>;
 
    FIterator CreateIterator() { return FIterator(*this, 0); }
    FConstIterator CreateConstIterator() const { return FConstIterator(*this, 0); }
 
    FIterator begin() { return FIterator(*this, 0); }
    FIterator end() { return FIterator(*this, NumItems); }
 
    FConstIterator begin() const { return FConstIterator(*this, 0); }
    FConstIterator end() const { return FConstIterator(*this, NumItems); }
 
    UE_API void AddStructReferencedObjects(FReferenceCollector& Collector);
    UE_API bool Identical(const FInstancedStructContainer* Other, uint32 PortFlags) const;
    UE_API bool Serialize(FArchive& Ar);
    UE_API void GetPreloadDependencies(TArray<UObject*>& OutDeps) const;
    UE_API bool ExportTextItem(FString& ValueStr, FInstancedStructContainer const& DefaultValue, UObject* Parent, int32 PortFlags, UObject* ExportRootScope) const;
    UE_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText, FArchive* InSerializingArchive = nullptr);
 
private:
 
    static constexpr int32 DefaultMinAlignment = alignof(void*);
 
    static constexpr int32 ItemStride = static_cast<int32>(Align(sizeof(FItem), alignof(FItem)));
 
    int32 GetItemOffset(const int32 Index) const
    {
        check(NumItems > 0 && Index < NumItems);
        return AllocatedSize - ((Index + 1) * ItemStride);
    }
 
    FItem& GetItem(const int32 Index) const
    {
        check(NumItems > 0 && Index < NumItems);
        const int32 Offset = AllocatedSize - ((Index + 1) * ItemStride);
        return *(FItem*)(Memory + Offset);
    }
 
    uint8* Memory = nullptr;
 
    int32 AllocatedSize = 0;
 
    int32 NumItems = 0;
 
    friend FIterator;
    friend FConstIterator;
};
 
template<>
struct TStructOpsTypeTraits<FInstancedStructContainer> : public TStructOpsTypeTraitsBase2<FInstancedStructContainer>
{
    enum
    {
        WithSerializer = true,
        WithIdentical = true,
        WithAddStructReferencedObjects = true,
        WithGetPreloadDependencies = true,
        WithExportTextItem = true,
        WithImportTextItem = true,
    };
};
 
#undef UE_API