SharedPointerArray.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/SharedPointer.h"
#include "uLang/Common/Misc/Optional.h"
#include "uLang/Common/Templates/Storage.h"
 
#include <initializer_list>
#include <type_traits>
 
namespace uLang
{
 
template<typename InElementType, bool AllowNull, typename InElementAllocatorType, typename... RawAllocatorArgsType>
class TSPtrArrayG
{
    template <typename OtherElementType, bool OtherAllowNull, typename OtherElementAllocatorType, typename... OtherRawAllocatorArgsType>
    friend class TSPtrArrayG;
 
public:
 
    using ElementType = InElementType;
    using ElementAllocatorType = InElementAllocatorType;
    using PointerType = TSPtrG<ElementType, AllowNull, typename InElementAllocatorType::RawAllocatorType, RawAllocatorArgsType...>;
    using PointerStorageType = TArrayG<ElementType *, InElementAllocatorType, RawAllocatorArgsType...>;
 
    ULANG_FORCEINLINE TSPtrArrayG(RawAllocatorArgsType&&... RawAllocatorArgs)
        : _PointerStorage(uLang::ForwardArg<RawAllocatorArgsType>(RawAllocatorArgs)...)
        , _DereferenceFunc(nullptr)
    {}
 
    template<typename OtherElementType, bool OtherAllowNull, typename = typename TEnableIf<std::is_convertible_v<OtherElementType*, InElementType*> && (AllowNull || !OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TSPtrArrayG(std::initializer_list<TSPtrG<OtherElementType, OtherAllowNull, typename InElementAllocatorType::RawAllocatorType, RawAllocatorArgsType...>> InitList, RawAllocatorArgsType&&... RawAllocatorArgs)
        : _PointerStorage(uLang::ForwardArg<RawAllocatorArgsType>(RawAllocatorArgs)...)
        , _DereferenceFunc(nullptr)
    {
        for(const TSPtrG<OtherElementType, OtherAllowNull, typename InElementAllocatorType::RawAllocatorType, RawAllocatorArgsType...>& Element : InitList)
        {
            Add(Element);
        }
    }
 
    template<typename OtherElementType, bool OtherAllowNull, typename = typename TEnableIf<std::is_convertible_v<OtherElementType*, InElementType*> && (AllowNull || !OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TSPtrArrayG(const TSPtrArrayG<OtherElementType, OtherAllowNull, InElementAllocatorType, RawAllocatorArgsType...>& Other)
        : _PointerStorage(Other._PointerStorage)
    {
        ReferenceAll();
        EnableDereference();
    }
 
    ULANG_FORCEINLINE TSPtrArrayG(const TSPtrArrayG& Other)
        : _PointerStorage(Other._PointerStorage)
    {
        ReferenceAll();
        EnableDereference();
    }
 
    template<typename OtherElementType, bool OtherAllowNull, typename = typename TEnableIf<std::is_convertible_v<OtherElementType*, InElementType*> && (AllowNull || !OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TSPtrArrayG(const TSPtrArrayG<OtherElementType, OtherAllowNull, InElementAllocatorType, RawAllocatorArgsType...>& Other, int32_t ExtraSlack)
        : _PointerStorage(Other._PointerStorage, ExtraSlack)
    {
        ReferenceAll();
        EnableDereference();
    }
 
    template<typename OtherElementType, bool OtherAllowNull, typename = typename TEnableIf<std::is_convertible_v<OtherElementType*, InElementType*> && (AllowNull || !OtherAllowNull)>::Type>
    TSPtrArrayG& operator=(const TSPtrArrayG<OtherElementType, OtherAllowNull, InElementAllocatorType, RawAllocatorArgsType...>& Other)
    {
        if (this != &Other)
        {
            _PointerStorage = Other._PointerStorage;
            ReferenceAll();
            EnableDereference();
        }
        return *this;
    }
    
    TSPtrArrayG& operator=(const TSPtrArrayG& Other)
    {
        if (this != &Other)
        {
            _PointerStorage = Other._PointerStorage;
            ReferenceAll();
            EnableDereference();
        }
        return *this;
    }
 
    template<typename OtherElementType, bool OtherAllowNull, typename = typename TEnableIf<std::is_convertible_v<OtherElementType*, InElementType*> && (AllowNull || !OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TSPtrArrayG(TSPtrArrayG<OtherElementType, OtherAllowNull, InElementAllocatorType, RawAllocatorArgsType...>&& Other)
        : _PointerStorage(ForwardArg<PointerStorageType>(Other._PointerStorage))
    {
        EnableDereference();
    }
    
    ULANG_FORCEINLINE TSPtrArrayG(TSPtrArrayG&& Other)
        : _PointerStorage(ForwardArg<PointerStorageType>(Other._PointerStorage))
    {
        EnableDereference();
    }
 
    template<class OtherElementType, bool OtherAllowNull, typename = typename TEnableIf<std::is_convertible_v<OtherElementType*, InElementType*> && (AllowNull || !OtherAllowNull)>::Type>
    TSPtrArrayG(TSPtrArrayG<OtherElementType, OtherAllowNull, InElementAllocatorType, RawAllocatorArgsType...>&& Other, int32_t ExtraSlack)
        : _PointerStorage(ForwardArg<PointerStorageType>(Other._PointerStorage), ExtraSlack)
    {
        EnableDereference();
    }
 
    template<class OtherElementType, bool OtherAllowNull, typename = typename TEnableIf<std::is_convertible_v<OtherElementType*, InElementType*> && (AllowNull || !OtherAllowNull)>::Type>
    TSPtrArrayG& operator=(TSPtrArrayG<OtherElementType, OtherAllowNull, InElementAllocatorType, RawAllocatorArgsType...>&& Other)
    {
        if (this != &Other)
        {
            DereferenceAll();
            _PointerStorage = ForwardArg<PointerStorageType>(Other._PointerStorage);
            EnableDereference();
        }
        return *this;
    }
 
    TSPtrArrayG& operator=(TSPtrArrayG&& Other)
    {
        if (this != &Other)
        {
            DereferenceAll();
            _PointerStorage = ForwardArg<PointerStorageType>(Other._PointerStorage);
            EnableDereference();
        }
        return *this;
    }
 
    ~TSPtrArrayG()
    {
        DereferenceAll();
    }
 
    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 PointerType operator[](int32_t Index) const
    {
        return PointerType(_PointerStorage[Index], _PointerStorage.GetRawAllocator());
    }
 
    ULANG_FORCEINLINE PointerType Pop(bool bAllowShrinking = true)
    {
        PointerType Item(_PointerStorage.Pop(bAllowShrinking), _PointerStorage.GetRawAllocator());
        if (Item)
        {
            Item->Dereference();
        }
        return Item;
    }
 
    ULANG_FORCEINLINE void Push(const PointerType & Item)
    {
        if (Item)
        {
            Item->Reference();
        }
        _PointerStorage.Push(Item.Get());
        EnableDereference();
    }
 
    ULANG_FORCEINLINE PointerType First() const
    {
        return PointerType(*_PointerStorage.GetData(), _PointerStorage.GetRawAllocator());
    }
 
    ULANG_FORCEINLINE PointerType Top() const
    {
        return PointerType(_PointerStorage.Top(), _PointerStorage.GetRawAllocator());
    }
 
    ULANG_FORCEINLINE PointerType Last(int32_t IndexFromTheEnd = 0) const
    {
        return PointerType(_PointerStorage.Last(IndexFromTheEnd), _PointerStorage.GetRawAllocator());
    }
 
    ULANG_FORCEINLINE void Shrink()
    {
        _PointerStorage.Shrink();
    }
 
    ULANG_FORCEINLINE bool Find(const ElementType* Item, int32_t& Index) const
    {
        return _PointerStorage.Find(const_cast<ElementType*>(Item), Index);
    }
    ULANG_FORCEINLINE bool Find(const PointerType& Item, int32_t& Index) const
    {
        return Find(Item.Get(), Index);
    }
 
 
    ULANG_FORCEINLINE int32_t Find(const ElementType* Item) const
    {
        return _PointerStorage.Find(const_cast<ElementType*>(Item));
    }
    ULANG_FORCEINLINE int32_t Find(const PointerType& Item) const
    {
        return Find(Item.Get());
    }
 
    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 TOptional<PointerType> FindByKey(const KeyType& Key) const
    {
        ElementType * const * Element = _PointerStorage.FindByPredicate([=](ElementType * Item) -> bool { return *Item == Key; });
        if (Element)
        {
            return PointerType(*Element, _PointerStorage.GetRawAllocator());
        }
 
        return EResult::Unspecified;
    }
 
    template <typename Predicate>
    ULANG_FORCEINLINE TOptional<PointerType> FindByPredicate(Predicate Pred) const
    {
        ElementType * const * Element = _PointerStorage.FindByPredicate(Pred);
        if (Element)
        {
            return PointerType(*Element, _PointerStorage.GetRawAllocator());
        }
 
        return EResult::Unspecified;
    }
 
    bool Contains(const PointerType& Pointer) const
    {
        return _PointerStorage.FindByPredicate([=](ElementType * Item) -> bool { return Item == Pointer.Get(); }) != 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);
        EnableDereference();
    }
 
    int32_t Insert(const TSPtrArrayG& Items, const int32_t InIndex)
    {
        _PointerStorage.Insert(Items._PointerStorage, InIndex);
        ReferenceRange(InIndex, InIndex + Items.Num());
        EnableDereference();
        return InIndex;
    }
 
    int32_t Insert(TSPtrArrayG&& Items, const int32_t InIndex)
    {
        EnableDereference();
        return _PointerStorage.Insert(ForwardArg<PointerStorageType>(Items._PointerStorage), InIndex);
    }
 
    int32_t Insert(const PointerType& Item, int32_t Index)
    {
        if (Item)
        {
            Item->Reference();
        }
        EnableDereference();
        return _PointerStorage.Insert(Item.Get(), Index);
    }
 
    ULANG_FORCEINLINE PointerType RemoveAt(int32_t Index)
    {
        PointerType RemovedItem(_PointerStorage[Index], _PointerStorage.GetRawAllocator());
        _PointerStorage.RemoveAt(Index);
        if (RemovedItem)
        {
            // Decrement the reference counter for the pointer removed from the array.
            RemovedItem->Dereference();
        }
        return uLang::Move(RemovedItem);
    }
 
    template <typename CountType>
    ULANG_FORCEINLINE void RemoveAt(int32_t Index, CountType Count, bool bAllowShrinking = true)
    {
        DereferenceRange(Index, Index + int32_t(Count));
        _PointerStorage.RemoveAt(Index, Count, bAllowShrinking);
    }
 
    ULANG_FORCEINLINE void RemoveAtSwap(int32_t Index)
    {
        Dereference(Index);
        _PointerStorage.RemoveAtSwap(Index);
    }
 
    template <typename CountType>
    ULANG_FORCEINLINE void RemoveAtSwap(int32_t Index, CountType Count, bool bAllowShrinking = true)
    {
        DereferenceRange(Index, Index + int32_t(Count));
        _PointerStorage.RemoveAtSwap(Index, Count, bAllowShrinking);
    }
 
    int32_t ReplaceAt(const PointerType& Item, int32_t Index)
    {
        if (Item)
        {
            Item->Reference();
        }
        EnableDereference();
        Dereference(Index);
        _PointerStorage[Index] = Item.Get();
        return Index;
    }
 
    void Reset(int32_t NewSize = 0)
    {
        DereferenceAll();
        _PointerStorage.Reset(NewSize);
    }
 
    void Empty(int32_t Slack = 0)
    {
        DereferenceAll();
        _PointerStorage.Empty(Slack);
    }
 
    void SetNumZeroed(int32_t NewNum, bool bAllowShrinking = true)
    {
        if (NewNum < Num())
        {
            DereferenceRange(NewNum, Num());
        }
        _PointerStorage.SetNumZeroed(NewNum, bAllowShrinking);
    }
 
    void Append(TSPtrArrayG& Source)
    {
        Source.ReferenceAll();
        _PointerStorage.Append(Source._PointerStorage);
        EnableDereference();
    }
 
    void Append(TSPtrArrayG&& Source)
    {
        _PointerStorage.Append(ForwardArg<PointerStorageType>(Source._PointerStorage));
        EnableDereference();
    }
 
    TSPtrArrayG& operator+=(TSPtrArrayG&& Other)
    {
        Append(ForwardArg<TSPtrArrayG>(Other));
        return *this;
    }
 
    TSPtrArrayG& operator+=(const TSPtrArrayG& Other)
    {
        Append(Other);
        return *this;
    }
 
    template <typename... CtorArgsType>
    ULANG_FORCEINLINE int32_t AddNew(CtorArgsType&&... CtorArgs)
    {
        ElementType * Item = new(_PointerStorage.GetRawAllocator()) ElementType(uLang::ForwardArg<CtorArgsType>(CtorArgs)...);
        Item->Reference();
        EnableDereference();
        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)...);
        Item->Reference();
        EnableDereference();
        _PointerStorage.EmplaceAt(Index, Item);
    }
 
    ULANG_FORCEINLINE int32_t Add(const PointerType& Item)
    {
        if (Item)
        {
            Item->Reference();
        }
        EnableDereference();
        return _PointerStorage.Emplace(Item.Get());
    }
 
    int32_t AddZeroed(int32_t Count = 1)
    {
        EnableDereference();
        return _PointerStorage.AddZeroed();
    }
 
    ULANG_FORCEINLINE int32_t AddUnique(const PointerType& Item)
    {
        int32_t NumPrev = _PointerStorage.Num();
        int32_t Index = _PointerStorage.AddUnique(Item.Get());
        if (Item && _PointerStorage.Num() > NumPrev)
        {
            Item->Reference();
        }
        EnableDereference();
        return Index;
    }
 
    ULANG_FORCEINLINE void Reserve(int32_t Number)
    {
        _PointerStorage.Reserve(Number);
    }
 
    int32_t RemoveSingle(const PointerType& Item)
    {
        int32_t Num = _PointerStorage.RemoveSingle(Item.Get());
        if (Num)
        {
            ULANG_ENSUREF(!Item->Dereference(), "Item was passed in so there must be at least one reference left after this.");
        }
        return Num;
    }
 
    int32_t Remove(const PointerType& Item)
    {
        int32_t Num = _PointerStorage.Remove(Item.Get());
        for (int32_t Count = Num; Count; --Count)
        {
            ULANG_ENSUREF(!Item->Dereference(), "Item was passed in so there must be at least one reference left after this.");
        }
        return Num;
    }
 
    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->Dereference())
            {
                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->Dereference())
            {
                Item->~ElementType();
                RawAllocator.Deallocate(Item);
            }
            return RemoveIt;
        });
    }
 
    int32_t RemoveSingleSwap(const PointerType& Item, bool bAllowShrinking = true)
    {
        int32_t Num = _PointerStorage.RemoveSingleSwap(Item.Get());
        if (Num)
        {
            ULANG_ENSUREF(!Item->Dereference(), "Item was passed in so there must be at least one reference left after this.");
        }
        return Num;
    }
 
    int32_t RemoveSwap(const PointerType& Item)
    {
        int32_t Num = _PointerStorage.RemoveSwap(Item.Get());
        for (int32_t Count = Num; Count; --Count)
        {
            ULANG_ENSUREF(!Item->Dereference(), "Item was passed in so there must be at least one reference left after this.");
        }
        return Num;
    }
 
    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 TSPtrArrayG<OtherElementType, OtherAllowNull, ElementAllocatorType, RawAllocatorArgsType...>& As() { return *reinterpret_cast<TSPtrArrayG<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 TSPtrArrayG<OtherElementType, OtherAllowNull, ElementAllocatorType, RawAllocatorArgsType...>& As() const { return *reinterpret_cast<const TSPtrArrayG<OtherElementType, OtherAllowNull, ElementAllocatorType, RawAllocatorArgsType...> *>(this); }
 
public:
 
    class Iterator
    {
    public:
        ULANG_FORCEINLINE Iterator() : _Item(nullptr) {} //-V730
        ULANG_FORCEINLINE Iterator(ElementType * const * Item, const typename InElementAllocatorType::RawAllocatorType & Allocator) : _Item(Item) { Ptr()._Allocator = Allocator; } //-V730
        ULANG_FORCEINLINE ~Iterator() = default;
        ULANG_FORCEINLINE const PointerType& operator*() const { ULANG_ASSERT(_Item); Ptr()._Object = *_Item; Ptr().EnableRelease(); return Ptr(); }
        ULANG_FORCEINLINE const ElementType* operator->() const { ULANG_ASSERT(_Item); return *_Item; }
        ULANG_FORCEINLINE bool               operator==(const Iterator & Other) const { return _Item == Other._Item; }
        ULANG_FORCEINLINE bool               operator!=(const Iterator & Other) const { return _Item != Other._Item; }
        ULANG_FORCEINLINE Iterator&          operator++()    { ++_Item; return *this; }
        ULANG_FORCEINLINE Iterator           operator++(int) { Iterator Temp = *this; ++*this; return Temp; }
        ULANG_FORCEINLINE Iterator&          operator--()    { --_Item; return *this; }
        ULANG_FORCEINLINE Iterator           operator--(int) { Iterator Temp = *this; --*this; return Temp; }
        friend ULANG_FORCEINLINE Iterator    operator+(const Iterator& Left, int32_t Right) { Iterator Temp = Left; Temp._Item += Right; return Temp; }
        friend ULANG_FORCEINLINE Iterator    operator+(int32_t Left, const Iterator& Right) { Iterator Temp = Right; Temp._Item += Left; return Temp; }
        friend ULANG_FORCEINLINE int32_t     operator-(const Iterator& Left, const Iterator& Right) { return static_cast<int32_t>(Left._Item - Right._Item); }
 
    protected:
        ULANG_FORCEINLINE PointerType& Ptr() const { return *(PointerType*)&_DummyPtr; }
 
        ElementType * const *             _Item;
        TTypeCompatibleBytes<PointerType> _DummyPtr; // Dummy shared pointer to avoid copy & unnecessary reference/dereference of object
    };
 
    ULANG_FORCEINLINE Iterator begin()       { return Iterator(_PointerStorage.begin(), _PointerStorage.GetRawAllocator()); }
    ULANG_FORCEINLINE Iterator begin() const { return Iterator(_PointerStorage.begin(), _PointerStorage.GetRawAllocator()); }
    ULANG_FORCEINLINE Iterator end()         { return Iterator(_PointerStorage.end(), _PointerStorage.GetRawAllocator()); }
    ULANG_FORCEINLINE Iterator end() const   { return Iterator(_PointerStorage.end(), _PointerStorage.GetRawAllocator()); }
 
protected:
 
    ULANG_FORCEINLINE void EnableDereference()
    {
        _DereferenceFunc = [](ElementType * Item, const typename ElementAllocatorType::RawAllocatorType & Allocator)
            {
                if (Item && Item->Dereference())
                {
                    // No references left: Delete the element
                    Item->~ElementType();
                    Allocator.Deallocate(Item);
                }
            };
    }
 
    ULANG_FORCEINLINE void Dereference(int32_t Index)
    {
        // Call the function set by EnableDereference() above
        (*_DereferenceFunc)(_PointerStorage[Index], _PointerStorage.GetRawAllocator());
    }
 
    ULANG_FORCEINLINE void ReferenceRange(int32_t BeginIndex, int32_t EndIndex)
    {
        for (int32_t Index = BeginIndex; Index < EndIndex; ++Index)
        {
            ElementType * Item = _PointerStorage[Index];
            if (Item) 
            {
                Item->Reference();
            }
        }
    }
 
    ULANG_FORCEINLINE void DereferenceRange(int32_t BeginIndex, int32_t EndIndex)
    {
        for (int32_t Index = BeginIndex; Index < EndIndex; ++Index)
        {
            Dereference(Index);
        }
    }
 
    ULANG_FORCEINLINE void ReferenceAll()
    {
        ReferenceRange(0, _PointerStorage.Num());
    }
 
    ULANG_FORCEINLINE void DereferenceAll()
    {
        DereferenceRange(0, _PointerStorage.Num());
    }
 
    PointerStorageType _PointerStorage;
 
    using DereferenceFuncType = void(*)(ElementType *, const typename ElementAllocatorType::RawAllocatorType &);
    DereferenceFuncType _DereferenceFunc;
};
 
template<typename ElementType>
using TSPtrArray = TSPtrArrayG<ElementType, true, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType>
using TSRefArray = TSPtrArrayG<ElementType, false, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType>
using TSPtrArrayA = TSPtrArrayG<ElementType, true, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
template<typename ElementType>
using TSRefArrayA = TSPtrArrayG<ElementType, false, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
 
template <typename ElementType, bool AllowNull, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsZeroConstructType<TSPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = TAllocatorTraits<ElementAllocatorType>::IsZeroConstruct };
};
 
template <typename ElementType, bool AllowNull, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TContainerTraits<TSPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>> : public TContainerTraitsBase<TSPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>>
{
    static_assert(TAllocatorTraits<ElementAllocatorType>::SupportsMove, "TSPtrArray no longer supports move-unaware allocators");
    enum { MoveWillEmptyContainer = TAllocatorTraits<ElementAllocatorType>::SupportsMove };
};
 
template <typename ElementType, bool AllowNull, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsContiguousContainer<TSPtrArrayG<ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = true };
};
 
}