juce_Range.h

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   The code included in this file is provided under the terms of the ISC license
   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
   To use, copy, modify, and/or distribute this software for any purpose with or
   without fee is hereby granted provided that the above copyright notice and
   this permission notice appear in all copies.
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
//==============================================================================
template <typename ValueType>
class Range
{
public:
    //==============================================================================
    constexpr Range() = default;
 
    constexpr Range (const ValueType startValue, const ValueType endValue) noexcept
        : start (startValue), end (jmax (startValue, endValue))
    {
    }
 
    constexpr Range (const Range&) = default;
 
    Range& operator= (const Range&) = default;
 
    constexpr static Range between (const ValueType position1, const ValueType position2) noexcept
    {
        return position1 < position2 ? Range (position1, position2)
                                     : Range (position2, position1);
    }
 
    [[nodiscard]] static Range withStartAndLength (const ValueType startValue, const ValueType length) noexcept
    {
        jassert (length >= ValueType());
        return Range (startValue, startValue + length);
    }
 
    [[nodiscard]] constexpr static Range emptyRange (const ValueType start) noexcept
    {
        return Range (start, start);
    }
 
    //==============================================================================
    constexpr inline ValueType getStart() const noexcept          { return start; }
 
    constexpr inline ValueType getLength() const noexcept         { return end - start; }
 
    constexpr inline ValueType getEnd() const noexcept            { return end; }
 
    constexpr inline bool isEmpty() const noexcept                { return exactlyEqual (start, end); }
 
    //==============================================================================
    void setStart (const ValueType newStart) noexcept
    {
        start = newStart;
        if (end < newStart)
            end = newStart;
    }
 
    [[nodiscard]] constexpr Range withStart (const ValueType newStart) const noexcept
    {
        return Range (newStart, jmax (newStart, end));
    }
 
    [[nodiscard]] constexpr Range movedToStartAt (const ValueType newStart) const noexcept
    {
        return Range (newStart, end + (newStart - start));
    }
 
    void setEnd (const ValueType newEnd) noexcept
    {
        end = newEnd;
        if (newEnd < start)
            start = newEnd;
    }
 
    [[nodiscard]] constexpr Range withEnd (const ValueType newEnd) const noexcept
    {
        return Range (jmin (start, newEnd), newEnd);
    }
 
    [[nodiscard]] constexpr Range movedToEndAt (const ValueType newEnd) const noexcept
    {
        return Range (start + (newEnd - end), newEnd);
    }
 
    void setLength (const ValueType newLength) noexcept
    {
        end = start + jmax (ValueType(), newLength);
    }
 
    [[nodiscard]] constexpr Range withLength (const ValueType newLength) const noexcept
    {
        return Range (start, start + newLength);
    }
 
    [[nodiscard]] constexpr Range expanded (ValueType amount) const noexcept
    {
        return Range (start - amount, end + amount);
    }
 
    //==============================================================================
    inline Range operator+= (const ValueType amountToAdd) noexcept
    {
        start += amountToAdd;
        end += amountToAdd;
        return *this;
    }
 
    inline Range operator-= (const ValueType amountToSubtract) noexcept
    {
        start -= amountToSubtract;
        end -= amountToSubtract;
        return *this;
    }
 
    constexpr Range operator+ (const ValueType amountToAdd) const noexcept
    {
        return Range (start + amountToAdd, end + amountToAdd);
    }
 
    constexpr Range operator- (const ValueType amountToSubtract) const noexcept
    {
        return Range (start - amountToSubtract, end - amountToSubtract);
    }
 
    constexpr bool operator== (Range other) const noexcept
    {
        const auto tie = [] (const Range& r) { return std::tie (r.start, r.end); };
        return tie (*this) == tie (other);
    }
 
    constexpr bool operator!= (Range other) const noexcept     { return ! operator== (other); }
 
    //==============================================================================
    constexpr bool contains (const ValueType position) const noexcept
    {
        return start <= position && position < end;
    }
 
    ValueType clipValue (const ValueType value) const noexcept
    {
        return jlimit (start, end, value);
    }
 
    constexpr bool contains (Range other) const noexcept
    {
        return start <= other.start && end >= other.end;
    }
 
    constexpr bool intersects (Range other) const noexcept
    {
        return other.start < end && start < other.end;
    }
 
    [[nodiscard]] constexpr Range getIntersectionWith (Range other) const noexcept
    {
        return Range (jmax (start, other.start),
                      jmin (end, other.end));
    }
 
    [[nodiscard]] constexpr Range getUnionWith (Range other) const noexcept
    {
        return Range (jmin (start, other.start),
                      jmax (end, other.end));
    }
 
    [[nodiscard]] constexpr Range getUnionWith (const ValueType valueToInclude) const noexcept
    {
        return Range (jmin (valueToInclude, start),
                      jmax (valueToInclude, end));
    }
 
    Range constrainRange (Range rangeToConstrain) const noexcept
    {
        const ValueType otherLen = rangeToConstrain.getLength();
        return getLength() <= otherLen
                ? *this
                : rangeToConstrain.movedToStartAt (jlimit (start, end - otherLen, rangeToConstrain.getStart()));
    }
 
    template <typename Integral, std::enable_if_t<std::is_integral_v<Integral>, int> = 0>
    static Range findMinAndMax (const ValueType* values, Integral numValues) noexcept
    {
        if (numValues <= 0)
            return Range();
 
        const ValueType first (*values++);
        Range r (first, first);
 
        while (--numValues > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
        {
            const ValueType v (*values++);
 
            if (r.end < v)    r.end = v;
            if (v < r.start)  r.start = v;
        }
 
        return r;
    }
 
private:
    //==============================================================================
    ValueType start{}, end{};
};
 
} // namespace juce