UniquePointerSet.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/UniquePointerArray.h"
 
namespace uLang
{
 
template<typename InElementType, bool AllowNull, typename InKeyType, typename InElementAllocatorType, typename... RawAllocatorArgsType>
class TUPtrSetG
    : protected TUPtrArrayG<InElementType, AllowNull, InElementAllocatorType, RawAllocatorArgsType...>
{
    template <typename OtherElementType, bool OtherAllowNull, typename OtherKeyType, typename OtherElementAllocatorType, typename... OtherRawAllocatorArgsType>
    friend class TUPtrSetG;
 
    using Super = TUPtrArrayG<InElementType, AllowNull, InElementAllocatorType, RawAllocatorArgsType...>;
    using Super::_PointerStorage;
    using Helper = TPointerSetHelper<InElementType, InKeyType>;
 
public:
 
    using KeyType = InKeyType;
    using typename Super::ElementType;
    using typename Super::PointerType;
 
    ULANG_FORCEINLINE TUPtrSetG(RawAllocatorArgsType&&... RawAllocatorArgs)
        : Super(uLang::ForwardArg<RawAllocatorArgsType>(RawAllocatorArgs)...)
    {}
 
    ULANG_FORCEINLINE TUPtrSetG(TUPtrSetG && Other)
        : Super(ForwardArg<Super>(Other))
    {
    }
 
    TUPtrSetG(TUPtrSetG && Other, int32_t ExtraSlack)
        : Super(ForwardArg<Super>(Other), ExtraSlack)
    {
    }
 
    // Use these superclass methods as-is:
    using Super::operator=;
    using Super::GetSlack;
    using Super::IsValidIndex;
    using Super::Num;
    using Super::Max;
    using Super::IsEmpty;
    using Super::IsFilled;
    using Super::operator[];
    using Super::Shrink;
    using Super::RemoveAt;
    using Super::ReplaceAt;
    using Super::Reset;
    using Super::Empty;
    using Super::Reserve;
    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 ElementType* Find(const KeyType& Key) const
    {
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, Key);
        if (UpperBound < Num())
        {
            ElementType* Item = _PointerStorage[UpperBound];
            if (KeyType(*Item) == Key)
            {
                return Item;
            }
        }
        return nullptr;
    }
 
    bool Contains(const KeyType& Key) const
    {
        int32_t UpperBound = Helper::GetUpperBound(_PointerStorage, Key);
        return UpperBound < Num() && KeyType(*_PointerStorage[UpperBound]) == Key;
    }
 
    void Append(const TUPtrSetG& Other)
    {
        Other.ReferenceAll();
        Merge(_PointerStorage, Other._PointerStorage);
    }
 
    void Append(TUPtrSetG&& Other)
    {
        Merge(_PointerStorage, Other._PointerStorage);
        Other.Empty();
    }
 
    TUPtrSetG& operator+=(TUPtrSetG&& Other)
    {
        Append(ForwardArg<TUPtrSetG>(Other));
        return *this;
    }
 
    TUPtrSetG& operator+=(const TUPtrSetG& 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)...);
        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(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(ForwardArg<PointerType>(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 TUPtrSet = TUPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType, typename KeyType>
using TURefSet = TUPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CHeapRawAllocator>>;
 
template<typename ElementType, typename KeyType>
using TUPtrSetA = TUPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
template<typename ElementType, typename KeyType>
using TURefSetA = TUPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>;
 
 
template <typename ElementType, bool AllowNull, typename KeyType, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsZeroConstructType<TUPtrSetG<ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = TAllocatorTraits<ElementAllocatorType>::IsZeroConstruct };
};
 
template <typename ElementType, bool AllowNull, typename KeyType, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TContainerTraits<TUPtrSetG<ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType...>> : public TContainerTraitsBase<TUPtrSetG<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 KeyType, typename ElementAllocatorType, typename... RawAllocatorArgsType>
struct TIsContiguousContainer<TUPtrSetG<ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType...>>
{
    enum { Value = true };
};
 
}