UniquePointerArray.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "uLang/Common/Containers/Array.h"
#include "uLang/Common/Containers/UniquePointer.h"
 
namespace uLang
{
 
template<typename InElementType, bool AllowNull, typename InElementAllocatorType, typename... RawAllocatorArgsType>
class TUPtrArrayG
{
    template <typename OtherElementType, bool OtherAllowNull, typename OtherElementAllocatorType, typename... OtherRawAllocatorArgsType>
    friend class TUPtrArrayG;
 
public:
 
    using ElementType = InElementType;
    using ElementAllocatorType = InElementAllocatorType;
    using PointerType = TUPtrG<ElementType, AllowNull, typename InElementAllocatorType::RawAllocatorType, RawAllocatorArgsType...>;
    using PointerStorageType = TArrayG<ElementType *, InElementAllocatorType, RawAllocatorArgsType...>;
 
    ULANG_FORCEINLINE TUPtrArrayG(RawAllocatorArgsType&&... RawAllocatorArgs)
        : _PointerStorage(uLang::ForwardArg<RawAllocatorArgsType>(RawAllocatorArgs)...)
    {}
 
    ULANG_FORCEINLINE TUPtrArrayG(TUPtrArrayG && Other)
        : _PointerStorage(ForwardArg<PointerStorageType>(Other._PointerStorage))
    {
    }
 
    TUPtrArrayG(TUPtrArrayG && Other, int32_t ExtraSlack)
        : _PointerStorage(ForwardArg<PointerStorageType>(Other._PointerStorage), ExtraSlack)
    {
    }
 
    TUPtrArrayG& operator=(TUPtrArrayG&& Other)
    {
        if (this != &Other)
        {
            DeleteAll();
            _PointerStorage = ForwardArg<PointerStorageType>(Other._PointerStorage);
        }
        return *this;
    }
 
    ~TUPtrArrayG()
    {
        DeleteAll();
    }
 
    ULANG_FORCEINLINE int32_t GetSlack() const
    {
        return _PointerStorage.GetSlack();
    }
 
    ULANG_FORCEINLINE bool IsValidIndex(int32_t Index) const
    {
        return _PointerStorage.IsValidIndex(Index);
    }
 
    ULANG_FORCEINLINE int32_t Num() const
    {
        return _PointerStorage.Num();
    }
 
    ULANG_FORCEINLINE int32_t Max() const
    {
        return _PointerStorage.Max();
    }
 
    ULANG_FORCEINLINE bool IsEmpty() const
    {
        return _PointerStorage.IsEmpty();
    }
 
    ULANG_FORCEINLINE bool IsFilled() const
    {
        return _PointerStorage.IsFilled();
    }
 
    ULANG_FORCEINLINE ElementType* operator[](int32_t Index) const
    {
        return _PointerStorage[Index];
    }
 
    ULANG_FORCEINLINE PointerType Pop(bool bAllowShrinking = true)
    {
        return PointerType(_PointerStorage.Pop(bAllowShrinking), _PointerStorage.GetRawAllocator());
    }
 
    ULANG_FORCEINLINE void Push(PointerType && Item)
    {
        ULANG_ASSERTF(_PointerStorage.GetRawAllocator() == Item.GetAllocator(), "Allocators must be compatible.");
        _PointerStorage.Push(Item.Get());
        Item._Object = nullptr;
    }
 
    ULANG_FORCEINLINE ElementType* Top() const
    {
        return _PointerStorage.Top();
    }
 
    ULANG_FORCEINLINE ElementType* Last(int32_t IndexFromTheEnd = 0) const
    {
        return _PointerStorage.Last(IndexFromTheEnd);
    }
 
    ULANG_FORCEINLINE void Shrink()
    {
        _PointerStorage.Shrink();
    }
 
    ULANG_FORCEINLINE bool Find(ElementType * Item, int32_t& Index) const
    {
        return _PointerStorage.Find(Item, Index);
    }
 
    ULANG_FORCEINLINE int32_t Find(ElementType * Item) const
    {
        return _PointerStorage.Find(Item);
    }
 
    ULANG_FORCEINLINE bool FindLast(const PointerType & Item, int32_t& Index) const
    {
        return _PointerStorage.FindLast(Item.Get(), Index);
    }
 
    ULANG_FORCEINLINE int32_t FindLast(const PointerType & Item) const
    {
        return _PointerStorage.FindLast(Item.Get());
    }
 
    template <typename Predicate>
    ULANG_FORCEINLINE int32_t FindLastByPredicate(Predicate Pred, int32_t Count) const
    {
        return _PointerStorage.FindLastByPredicate(Pred, Count);
    }
 
    template <typename Predicate>
    ULANG_FORCEINLINE int32_t FindLastByPredicate(Predicate Pred) const
    {
        return _PointerStorage.FindLastByPredicate(Pred);
    }
 
    template <typename KeyType>
    int32_t IndexOfByKey(const KeyType& Key) const
    {
        return _PointerStorage.IndexOfByPredicate([=](ElementType * Item) -> bool { return *Item == Key; });
    }
 
    template <typename Predicate>
    int32_t IndexOfByPredicate(Predicate Pred) const
    {
        return _PointerStorage.IndexOfByPredicate(Pred);
    }
 
    template <typename KeyType>
    ULANG_FORCEINLINE ElementType* FindByKey(const KeyType& Key) const
    {
        ElementType * const * Element = _PointerStorage.FindByPredicate([=](ElementType * Item) -> bool { return *Item == Key; });
        return Element ? *Element : nullptr;
    }
 
    template <typename Predicate>
    ULANG_FORCEINLINE ElementType* FindByPredicate(Predicate Pred) const
    {
        ElementType * const * Element = _PointerStorage.FindByPredicate(Pred);
        return Element ? *Element : nullptr;
    }
 
    bool Contains(const ElementType* Pointer) const
    {
        return _PointerStorage.FindByPredicate([=](ElementType * Item) -> bool { return Item == Pointer; }) != nullptr;
    }
 
    template <typename ComparisonType>
    bool ContainsByKey(const ComparisonType& Key) const
    {
        return _PointerStorage.FindByPredicate([=](ElementType * Item) -> bool { return *Item == Key; }) != nullptr;
    }
 
    template <typename Predicate>
    ULANG_FORCEINLINE bool ContainsByPredicate(Predicate Pred) const
    {
        return _PointerStorage.ContainsByPredicate(Pred);
    }
 
    void InsertZeroed(int32_t Index, int32_t Count = 1)
    {
        _PointerStorage.InsertZeroed(Index, Count);
    }
 
    int32_t Insert(TUPtrArrayG&& Items, const int32_t InIndex)
    {
        return _PointerStorage.Insert(ForwardArg<PointerStorageType>(Items._PointerStorage), InIndex);
    }
 
    int32_t Insert(PointerType&& Item, int32_t Index)
    {
        ElementType* ItemPtr = Item.Get();
        Item._Object = nullptr;
        return _PointerStorage.Insert(ItemPtr, Index);
    }
 
    ULANG_FORCEINLINE PointerType RemoveAt(int32_t Index)
    {
        PointerType RemovedItem(_PointerStorage[Index], _PointerStorage.GetRawAllocator());
        _PointerStorage.RemoveAt(Index);
        return uLang::Move(RemovedItem);
    }
 
    template <typename CountType>
    ULANG_FORCEINLINE void RemoveAt(int32_t Index, CountType Count, bool bAllowShrinking = true)
    {
        DeleteRange(Index, Index + int32_t(Count));
        _PointerStorage.RemoveAt(Index, Count, bAllowShrinking);
    }
 
    ULANG_FORCEINLINE PointerType RemoveAtSwap(int32_t Index)
    {
        PointerType RemovedItem(_PointerStorage[Index], _PointerStorage.GetRawAllocator());
        _PointerStorage.RemoveAtSwap(Index);
        return uLang::Move(RemovedItem);
    }
 
    template <typename CountType>
    ULANG_FORCEINLINE void RemoveAtSwap(int32_t Index, CountType Count, bool bAllowShrinking = true)
    {
        DeleteRange(Index, Index + int32_t(Count));
        _PointerStorage.RemoveAtSwap(Index, Count, bAllowShrinking);
    }
 
    int32_t ReplaceAt(PointerType&& Item, int32_t Index)
    {
        Delete(Index);
        ElementType* ItemPtr = Item.Get();
        Item._Object = nullptr;
        _PointerStorage[Index] = ItemPtr;
        return Index;
    }
 
    void Reset(int32_t NewSize = 0)
    {
        DeleteAll();
        _PointerStorage.Reset(NewSize);
    }
 
    void Empty(int32_t Slack = 0)
    {
        DeleteAll();
        _PointerStorage.Empty(Slack);
    }
 
    void SetNumZeroed(int32_t NewNum, bool bAllowShrinking = true)
    {
        if (NewNum < Num())
        {
            DeleteRange(NewNum, Num());
        }
        _PointerStorage.SetNumZeroed(NewNum, bAllowShrinking);
    }
 
    void Append(TUPtrArrayG&& Source)
    {
        _PointerStorage.Append(ForwardArg<PointerStorageType>(Source._PointerStorage));
    }
 
    TUPtrArrayG& operator+=(TUPtrArrayG&& Other)
    {
        Append(ForwardArg<TUPtrArrayG>(Other));
        return *this;
    }
 
    template <typename... CtorArgsType>
    ULANG_FORCEINLINE int32_t AddNew(CtorArgsType&&... CtorArgs)
    {
        ElementType * Item = new(_PointerStorage.GetRawAllocator()) ElementType(uLang::ForwardArg<CtorArgsType>(CtorArgs)...);
        return _PointerStorage.Emplace(Item);
    }
 
    template <typename... CtorArgsType>
    ULANG_FORCEINLINE void InsertNew(int32_t Index, CtorArgsType&&... CtorArgs)
    {
        ElementType * Item = new(_PointerStorage.GetRawAllocator()) ElementType(uLang::ForwardArg<CtorArgsType>(CtorArgs)...);
        _PointerStorage.EmplaceAt(Index, Item);
    }
 
    ULANG_FORCEINLINE int32_t Add(PointerType&& Item)
    {
        ElementType* ItemPtr = Item.Get();
        Item._Object = nullptr;
        return _PointerStorage.Emplace(ItemPtr);
    }
 
    int32_t AddZeroed(int32_t Count = 1)
    {
        return _PointerStorage.AddZeroed();
    }
 
    ULANG_FORCEINLINE int32_t AddUnique(PointerType&& Item)
    {
        int32_t NumPrev = _PointerStorage.Num();
        int32_t Index = _PointerStorage.AddUnique(Item.Get());
        if (_PointerStorage.Num() > NumPrev)
        {
            Item._Object = nullptr;
        }
        return Index;
    }
 
    ULANG_FORCEINLINE void Reserve(int32_t Number)
    {
        _PointerStorage.Reserve(Number);
    }
 
    template <typename Predicate>
    int32_t RemoveAll(const Predicate& Pred)
    {
        const typename ElementAllocatorType::RawAllocatorType & RawAllocator = _PointerStorage.GetRawAllocator();
        return _PointerStorage.RemoveAll([&](ElementType* Item) -> bool {
            bool RemoveIt = Pred(Item);
            if (RemoveIt)
            {
                Item->~ElementType();
                RawAllocator.Deallocate(Item);
            }
            return RemoveIt;
        });
    }
 
    template <class Predicate>
    void RemoveAllSwap(const Predicate& Pred, bool bAllowShrinking = true)
    {
        const typename ElementAllocatorType::RawAllocatorType & RawAllocator = _PointerStorage.GetRawAllocator();
        return _PointerStorage.RemoveAllSwap([&](ElementType* Item) -> bool {
            bool RemoveIt = Pred(Item);
            if (RemoveIt)
            {
                Item->~ElementType();
                RawAllocator.Deallocate(Item);
            }
            return RemoveIt;
        });
    }
 
    void Sort()
    {
        Algo::Sort( _PointerStorage, TDereferenceWrapper<TLess<ElementType>>( TLess<ElementType>() ) );
    }
 
    template <class PredicateType>
    void Sort(const PredicateType& Predicate)
    {
        Algo::Sort( _PointerStorage, Predicate );
    }
 
    template<class OtherElementType, bool OtherAllowNull = AllowNull, typename = typename TEnableIf<TPointerIsStaticCastableFromTo<OtherElementType, ElementType>::Value && (AllowNull == OtherAllowNull || OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TUPtrArrayG<OtherElementType, OtherAllowNull, ElementAllocatorType, RawAllocatorArgsType...>& As() { return *reinterpret_cast<TUPtrArrayG<OtherElementType, OtherAllowNull, ElementAllocatorType, RawAllocatorArgsType...> *>(this); }
    template<class OtherElementType, bool OtherAllowNull = AllowNull, typename = typename TEnableIf<TPointerIsStaticCastableFromTo<OtherElementType, ElementType>::Value && (AllowNull == OtherAllowNull || OtherAllowNull)>::Type>
    ULANG_FORCEINLINE const TUPtrArrayG<OtherElementType, OtherAllowNull, ElementAllocatorType, RawAllocatorArgsType...>& As() const { return *reinterpret_cast<const TUPtrArrayG<OtherElementType, OtherAllowNull, ElementAllocatorType, RawAllocatorArgsType...> *>(this); }
 
public:
 
    ULANG_FORCEINLINE ElementType **        begin()       { return _PointerStorage.begin(); }
    ULANG_FORCEINLINE ElementType * const * begin() const { return _PointerStorage.begin(); }
    ULANG_FORCEINLINE ElementType **        end()         { return _PointerStorage.end(); }
    ULANG_FORCEINLINE ElementType * const * end() const   { return _PointerStorage.end(); }
 
protected:
 
    ULANG_FORCEINLINE void Delete(int32_t Index)
    {
        ElementType * Item = _PointerStorage[Index];
        if (Item)
        {
            Item->~ElementType();
            _PointerStorage.GetRawAllocator().Deallocate(Item);
        }
    }
 
    ULANG_FORCEINLINE void DeleteRange(int32_t BeginIndex, int32_t EndIndex)
    {
        for (int32_t Index = BeginIndex; Index < EndIndex; ++Index)
        {
            Delete(Index);
        }
    }
 
    ULANG_FORCEINLINE void DeleteAll()
    {
        DeleteRange(0, _PointerStorage.Num());
    }
 
    PointerStorageType _PointerStorage;
 
};
 
template<typename ElementType>
using TUPtrArray = TUPtrArrayG<ElementType, true, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType>
using TURefArray = TUPtrArrayG<ElementType, false, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType>
using TUPtrArrayA = TUPtrArrayG<ElementType, true, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
template<typename ElementType>
using TURefArrayA = TUPtrArrayG<ElementType, false, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
 
template <typename ElementType, bool AllowNull, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsZeroConstructType<TUPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = TAllocatorTraits<ElementAllocatorType>::IsZeroConstruct };
};
 
template <typename ElementType, bool AllowNull, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TContainerTraits<TUPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>> : public TContainerTraitsBase<TUPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>>
{
    static_assert(TAllocatorTraits<ElementAllocatorType>::SupportsMove, "TUPtrArray no longer supports move-unaware allocators");
    enum { MoveWillEmptyContainer = TAllocatorTraits<ElementAllocatorType>::SupportsMove };
};
 
template <typename ElementType, bool AllowNull, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsContiguousContainer<TUPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = true };
};
 
}