SlateElementSortedArray.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/BinarySearch.h"
#include "Containers/Array.h"
#include "Templates/UnrealTypeTraits.h"
 
template <typename InElementType, typename InSortPredicate = TLess<>>
class TSlateElementSortedArray
{
    using DataType = TArray<InElementType>;
    DataType Data;
 
public:
    using SizeType = typename DataType::SizeType;
    using ElementType = InElementType;
    using ElementParamType = typename TCallTraits<ElementType>::ParamType;
    using SortPredicate = TLess<>;
 
public:
    FORCEINLINE ElementParamType operator[](SizeType Index) const
    {
        return Data.GetData()[Index];
    }
 
public:
    FORCEINLINE void Empty(SizeType ExpectedNumElements = 0)
    {
        Data.Empty(ExpectedNumElements);
    }
 
    FORCEINLINE bool IsValidIndex(SizeType Index) const
    {
        return Data.IsValidIndex(Index);
    }
 
    FORCEINLINE SizeType Num() const
    {
        return Data.Num();
    }
 
public:
    SizeType Find(ElementParamType Item) const
    {
        return Algo::BinarySearch(Data, Item, SortPredicate());
    }
 
    bool Contains(ElementParamType Item) const
    {
        return Find(Item) != INDEX_NONE;
    }
 
    SizeType FindLowerBound(ElementParamType Value) const
    {
        const SizeType FoundIndex = Algo::LowerBound(Data, Value, SortPredicate());
        return Data.IsValidIndex(FoundIndex) ? FoundIndex : INDEX_NONE;
    }
 
    SizeType FindUpperBound(ElementParamType Value) const
    {
        const SizeType FoundIndex = Algo::UpperBound(Data, Value, SortPredicate());
        return Data.IsValidIndex(FoundIndex) ? FoundIndex : INDEX_NONE;
    }
 
public:
    SizeType InsertUnique(ElementParamType Item)
    {
        SizeType LowerBoundIndex = Algo::LowerBound(Data, Item, SortPredicate());
        if (LowerBoundIndex >= Num() || SortPredicate()(Item, Data.GetData()[LowerBoundIndex]))
        {
            return Data.Insert(Item, LowerBoundIndex);
        }
        return 0;
    }
 
    FORCEINLINE SizeType AddUnsorted(ElementType Item)
    {
        return Data.Add(Item);
    }
 
    SizeType RemoveSingle(ElementParamType Item)
    {
        SizeType Index = Find(Item);
        if (Index != INDEX_NONE)
        {
            Data.RemoveAt(Index, EAllowShrinking::No);
            return 1;
        }
        return 0;
    }
 
    template <typename CountType>
    FORCEINLINE void RemoveAt(SizeType Index, CountType Count)
    {
        Data.RemoveAt(Index, Count, EAllowShrinking::No);
    }
 
    void Sort()
    {
        Algo::Sort(Data, SortPredicate());
    }
 
public:
    using RangedForConstIteratorType = typename DataType::RangedForConstIteratorType;
    FORCEINLINE RangedForConstIteratorType  begin() const { return Data.begin(); }
    FORCEINLINE RangedForConstIteratorType  end() const { return Data.end(); }
};