SharedPointerSet.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "uLang/Common/Containers/PointerSetHelper.h"
#include "uLang/Common/Containers/SharedPointerArray.h"
#include "uLang/Common/Misc/Optional.h"
 
namespace uLang
{
 
template<typename InElementType, bool AllowNull, typename InKeyType, typename InElementAllocatorType, typename... RawAllocatorArgsType>
class TSPtrSetG
    : protected TSPtrArrayG<InElementType, AllowNull, InElementAllocatorType, RawAllocatorArgsType...>
{
    template <typename OtherElementType, bool OtherAllowNull, typename OtherKeyType, typename OtherElementAllocatorType, typename... OtherRawAllocatorArgsType>
    friend class TSPtrSetG;
 
    using Super = TSPtrArrayG<InElementType, AllowNull, InElementAllocatorType, RawAllocatorArgsType...>;
    using Super::_PointerStorage;
    using Helper = TPointerSetHelper<InElementType, InKeyType>;
 
public:
 
    using KeyType = InKeyType;
    using typename Super::ElementType;
    using typename Super::PointerType;
    using Super::EnableDereference;
 
    ULANG_FORCEINLINE TSPtrSetG(RawAllocatorArgsType&&... RawAllocatorArgs)
        : Super(uLang::ForwardArg<RawAllocatorArgsType>(RawAllocatorArgs)...)
    {}
 
    ULANG_FORCEINLINE TSPtrSetG(const TSPtrSetG & Other)
        : Super(Other)
    {
    }
 
    ULANG_FORCEINLINE TSPtrSetG(const TSPtrSetG & Other, int32_t ExtraSlack)
        : Super(Other, ExtraSlack)
    {
    }
 
    ULANG_FORCEINLINE TSPtrSetG(TSPtrSetG && Other)
        : Super(ForwardArg<Super>(Other))
    {
    }
 
    TSPtrSetG(TSPtrSetG && Other, int32_t ExtraSlack)
        : Super(ForwardArg<Super>(Other), ExtraSlack)
    {
    }
 
    TSPtrSetG& operator=(const TSPtrSetG& Other) { Super::operator=(Other); return *this; }
    TSPtrSetG& operator=(TSPtrSetG&& Other) { Super::operator=(Move(Other)); return *this; }
 
    // Use these superclass methods as-is:
    using Super::GetSlack;
    using Super::IsValidIndex;
    using Super::Num;
    using Super::Max;
    using Super::IsEmpty;
    using Super::IsFilled;
    using Super::operator[];
    using Super::FindByPredicate;
    using Super::IndexOfByPredicate;
    using Super::Shrink;
    using Super::RemoveAt;
    using Super::ReplaceAt;
    using Super::Reset;
    using Super::Empty;
    using Super::Reserve;
    using typename Super::Iterator;
    using Super::begin;
    using Super::end;
 
    int32_t IndexOf(const KeyType& Key) const
    {
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, Key);
        return (UpperBound < Num() && KeyType(*_PointerStorage[UpperBound]) == Key) ? UpperBound : IndexNone;
    }
 
    ULANG_FORCEINLINE TOptional<PointerType> Find(const KeyType& Key) const
    {
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, Key);
        if (UpperBound < Num())
        {
            ElementType* Item = _PointerStorage[UpperBound];
            if (KeyType(*Item) == Key)
            {
                return PointerType(Item, _PointerStorage.GetRawAllocator());
            }
        }
        return TOptional<PointerType>();
    }
 
    bool Contains(const KeyType& Key) const
    {
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, Key);
        return UpperBound < Num() && KeyType(*_PointerStorage[UpperBound]) == Key;
    }
 
    void Append(const TSPtrSetG& Other)
    {
        Other.ReferenceAll();
        Merge(_PointerStorage, Other._PointerStorage);
        EnableDereference();
    }
 
    void Append(TSPtrSetG&& Other)
    {
        Merge(_PointerStorage, Other._PointerStorage);
        Other.Empty();
        EnableDereference();
    }
 
    TSPtrSetG& operator+=(TSPtrSetG&& Other)
    {
        Append(ForwardArg<TSPtrSetG>(Other));
        return *this;
    }
 
    TSPtrSetG& operator+=(const TSPtrSetG& 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();
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, *Item);
        ULANG_ASSERTF(UpperBound == Num() || KeyType(*_PointerStorage[UpperBound]) != KeyType(*Item), "Tried to add duplicate item!");
        _PointerStorage.EmplaceAt(UpperBound, Item);
        return UpperBound;
    }
 
    ULANG_FORCEINLINE int32_t Add(const PointerType& Item)
    {
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, *Item);
        ULANG_ASSERTF(UpperBound == Num() || KeyType(*_PointerStorage[UpperBound]) != KeyType(*Item), "Tried to add duplicate item!");
        return Super::Insert(Item, UpperBound);
    }
 
    int32_t Remove(const KeyType& Key)
    {
        int32_t Count = 0;
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, Key);
        if (UpperBound < Num() && KeyType(*_PointerStorage[UpperBound]) == Key)
        {
            Super::RemoveAt(UpperBound);
            ++Count;
        }
        ULANG_ASSERTF(UpperBound == Num() || KeyType(*_PointerStorage[UpperBound]) != Key, "Matching item still present after Remove()!");
        return Count;
    }
 
};
 
template<typename ElementType, typename KeyType>
using TSPtrSet = TSPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType, typename KeyType>
using TSRefSet = TSPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType, typename KeyType>
using TSPtrSetA = TSPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
template<typename ElementType, typename KeyType>
using TSRefSetA = TSPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
 
template <typename ElementType, bool AllowNull, typename KeyType, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsZeroConstructType<TSPtrSetG<ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = TAllocatorTraits<ElementAllocatorType>::IsZeroConstruct };
};
 
template <typename ElementType, bool AllowNull, typename KeyType, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TContainerTraits<TSPtrSetG<ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType...>> : public TContainerTraitsBase<TSPtrSetG<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 KeyType, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsContiguousContainer<TSPtrSetG<ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = true };
};
 
}