RangeSet.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/Array.h"
#include "Math/Range.h"
#include "Serialization/Archive.h"
 
 
template<typename ElementType> class TRangeSet
{
    typedef TRangeBound<ElementType> BoundsType;
    typedef TRange<ElementType> RangeType;
 
    /*~ Typedef used to pass/return small element types by value rather than const& */
    typedef typename TCallTraits<ElementType>::ParamType ElementValueOrConstRef;
 
public:
 
    [[nodiscard]] TRangeSet() { }
 
    ~TRangeSet() { }
 
public:
    
    void Add(RangeType Range)
    {
        for (int32 Index = 0; Index < Ranges.Num(); ++Index)
        {
            const RangeType& Current = Ranges[Index];
 
            if (Current.Adjoins(Range) || Current.Overlaps(Range))
            {
                Range = RangeType(
                    BoundsType::MinLower(Current.GetLowerBound(), Range.GetLowerBound()),
                    BoundsType::MaxUpper(Current.GetUpperBound(), Range.GetUpperBound())
                );
 
                Ranges.RemoveAtSwap(Index--);
            }
        }
 
        Ranges.Add(Range);
    }
 
    void Merge(const TRangeSet& Other)
    {
        for (typename TArray<RangeType>::TConstIterator It(Other.Ranges); It; ++It)
        {
            Add(*It);
        }
    }
 
    void Remove(const RangeType& Range)
    {
        for (int32 Index = 0; Index < Ranges.Num(); ++Index)
        {
            const RangeType& Current = Ranges(Index);
 
            if (Current.Overlaps(Range))
            {
                if (Current.GetLowerBound() < Range.GetLowerBound())
                {
                    Ranges.Add(RangeType(Current.GetLowerBound(), Range.GetLowerBound()));
                }
 
                if (Current.GetUpperBound() > Range.GetUpperBound())
                {
                    Ranges.Add(RangeType(Range.GetUpperBound(), Current.GetUpperBound()));
                }
 
                Ranges.RemoveAtSwap(Index--);
            }
        }
    }*/
 
    void Empty()
    {
        Ranges.Empty();
    }
    
public:
    
    [[nodiscard]] bool Contains(ElementValueOrConstRef Element) const
    {
        for (typename TArray<RangeType>::TConstIterator It(Ranges); It; ++It)
        {
            if (It->Contains(Element))
            {
                return true;
            }
        }
 
        return false;
    }
    
    [[nodiscard]] bool Contains(const RangeType& Range) const
    {
        for (typename TArray<RangeType>::TConstIterator It(Ranges); It; ++It)
        {
            if (It->Contains(Range))
            {
                return true;
            }
        }
 
        return false;
    }
 
    [[nodiscard]] BoundsType GetMinBound() const
    {
        BoundsType Result;
 
        if (Ranges.Num())
        {
            Result = Ranges[0].GetLowerBound();
            for (int32 i = 1; i < Ranges.Num(); i++)
            {
                Result = BoundsType::MinLower(Result, Ranges[i].GetLowerBound());
            }
        }
 
        return Result;
    }
 
    [[nodiscard]] ElementType GetMinBoundValue() const
    {
        return GetMinBound().GetValue();
    }
 
    [[nodiscard]] BoundsType GetMaxBound() const
    {
        BoundsType Result;
 
        if (Ranges.Num())
        {
            Result = Ranges[0].GetUpperBound();
            for (int32 i = 1; i < Ranges.Num(); i++)
            {
                Result = BoundsType::MaxUpper(Result, Ranges[i].GetUpperBound());
            }
        }
 
        return Result;
    }
 
    [[nodiscard]] ElementType GetMaxBoundValue() const
    {
        return GetMaxBound().GetValue();
    }
 
 
    template<typename Allocator>
    const void GetRanges(TArray<RangeType, Allocator>& OutRanges) const
    {
        OutRanges = Ranges;
    }
    
    [[nodiscard]] bool HasMinBound() const
    {
        return GetMinBound().IsClosed();
    }
    
    [[nodiscard]] bool HasMaxBound() const
    {
        return GetMaxBound().IsClosed();
    }
 
    [[nodiscard]] bool IsEmpty() const
    {
        return (Ranges.Num() == 0);
    }
    
    [[nodiscard]] bool Overlaps(const RangeType& Range) const
    {
        for (typename TArray<RangeType>::TConstIterator It(Ranges); It; ++It)
        {
            if (It->Overlaps(Range))
            {
                return true;
            }
        }
 
        return false;
    }
    
    [[nodiscard]] bool Overlaps(const TRangeSet& Other) const
    {
        for (typename TArray<RangeType>::TConstIterator It(Other.Ranges); It; ++It)
        {
            if (Overlaps(*It))
            {
                return true;
            }
        }
 
        return false;
    }
 
public:
 
    friend class FArchive& operator<<(class FArchive& Ar, TRangeSet& RangeSet)
    {
        return Ar << RangeSet.Ranges;
    }
 
private:
 
    TArray<RangeType> Ranges;
};