tracktion_TimeRange.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
#pragma once
 
#include "tracktion_Time.h"
 
namespace tracktion { inline namespace core
{
 
template<typename PositionType>
struct RangeType;
 
//==============================================================================
//==============================================================================
using TimeRange = RangeType<TimePosition>;
 
using BeatRange = RangeType<BeatPosition>;
 
 
//==============================================================================
[[ nodiscard ]] juce::Range<int64_t> toSamples (TimeRange, double sampleRate);
 
[[ nodiscard ]] TimeRange timeRangeFromSamples (juce::Range<int64_t> sampleRange, double sampleRate);
 
template<typename SourceRangeType>
[[ nodiscard ]] TimeRange timeRangeFromSeconds (SourceRangeType);
 
//==============================================================================
//==============================================================================
template<typename PositionType>
struct RangeType
{
    using Position = PositionType;                      
    using Duration = typename Position::DurationType;   
    //==============================================================================
    RangeType() = default;
 
    RangeType (const RangeType&) = default;
 
    RangeType& operator= (const RangeType&) = default;
 
    RangeType (Position start, Position end);
 
    RangeType (Position start, Duration);
 
    static RangeType endingAt (Position end, Duration);
 
    static RangeType between (Position, Position);
 
    static RangeType emptyRange (Position);
 
    //==============================================================================
    constexpr Position getStart() const;
 
    constexpr Position getEnd() const;
 
    constexpr Duration getLength() const;
 
    constexpr Position getCentre() const;
 
    Position clipPosition (Position) const;
 
    //==============================================================================
    bool isEmpty() const;
 
    bool overlaps (const RangeType&) const;
 
    bool contains (const RangeType&) const;
 
    bool intersects (const RangeType&) const;
 
    bool contains (Position) const;
 
    bool containsInclusive (Position) const;
 
    //==============================================================================
    [[ nodiscard ]] RangeType getUnionWith (RangeType) const;
 
    [[ nodiscard ]] RangeType getIntersectionWith (RangeType) const;
 
    [[ nodiscard ]] RangeType rescaled (Position anchorTime, double factor) const;
 
    [[ nodiscard ]] RangeType constrainRange (RangeType) const;
 
    [[ nodiscard ]] RangeType expanded (Duration) const;
 
    [[ nodiscard ]] RangeType reduced (Duration) const;
 
    [[ nodiscard ]] RangeType movedToStartAt (Position) const;
 
    [[ nodiscard ]] RangeType movedToEndAt (Position) const;
 
    [[ nodiscard ]] RangeType withStart (Position) const;
 
    [[ nodiscard ]] RangeType withEnd (Position) const;
 
    [[ nodiscard ]] RangeType withLength (Duration) const;
 
private:
    Position start, end;
 
    void checkInvariants() const;
};
 
//==============================================================================
template<typename PositionType>
[[ nodiscard ]] bool operator== (const RangeType<PositionType>&, const RangeType<PositionType>&);
 
template<typename PositionType>
[[ nodiscard ]] bool operator!= (const RangeType<PositionType>&, const RangeType<PositionType>&);
 
template<typename PositionType>
[[ nodiscard ]] RangeType<PositionType> operator+ (const RangeType<PositionType>&, typename RangeType<PositionType>::Duration);
 
template<typename PositionType>
[[ nodiscard ]] RangeType<PositionType> operator- (const RangeType<PositionType>&, typename RangeType<PositionType>::Duration);
 
//==============================================================================
template<typename PositionType>
[[ nodiscard ]] RangeType<PositionType> withEndExtended (RangeType<PositionType>&, typename RangeType<PositionType>::Duration);
 
//==============================================================================
//        _        _           _  _
//     __| |  ___ | |_   __ _ (_)| | ___
//    / _` | / _ \| __| / _` || || |/ __|
//   | (_| ||  __/| |_ | (_| || || |\__ \ _  _  _
//    \__,_| \___| \__| \__,_||_||_||___/(_)(_)(_)
//
//   Code beyond this point is implementation detail...
//
//==============================================================================
template<typename PositionType>
PositionType fromUnderlyingType (double);
 
template<> inline TimePosition fromUnderlyingType<TimePosition> (double t) { return TimePosition::fromSeconds (t); }
template<> inline TimeDuration fromUnderlyingType<TimeDuration> (double t) { return TimeDuration::fromSeconds (t); }
inline double toUnderlyingType (TimePosition t) { return t.inSeconds(); }
inline double toUnderlyingType (TimeDuration t) { return t.inSeconds(); }
 
template<> inline BeatPosition fromUnderlyingType<BeatPosition> (double t) { return BeatPosition::fromBeats (t); }
template<> inline BeatDuration fromUnderlyingType<BeatDuration> (double t) { return BeatDuration::fromBeats (t); }
inline double toUnderlyingType (BeatPosition t) { return t.inBeats(); }
inline double toUnderlyingType (BeatDuration t) { return t.inBeats(); }
 
inline TimeRange timeRangeFromSamples (juce::Range<int64_t> r, double sampleRate)
{
    return { TimePosition::fromSamples (r.getStart(), sampleRate),
             TimePosition::fromSamples (r.getEnd(), sampleRate) };
}
 
template<typename SourceRangeType>
inline TimeRange timeRangeFromSeconds (SourceRangeType r)
{
    return { TimePosition::fromSeconds (r.getStart()),
             TimePosition::fromSeconds (r.getEnd()) };
}
 
template<typename PositionType>
inline RangeType<PositionType>::RangeType (Position s, Position e)
    : start (s), end (e)
{
    checkInvariants();
}
 
template<typename PositionType>
inline RangeType<PositionType>::RangeType (Position s, Duration d)
    : start (s), end (s + d)
{
    checkInvariants();
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::endingAt (Position e, Duration d)
{
    return RangeType (e - d, e);
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::between (Position p1, Position p2)
{
    return p1 < p2 ? RangeType (p1, p2)
                   : RangeType (p2, p1);
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::emptyRange (Position p)
{
    return { p, p };
}
 
template<typename PositionType> inline constexpr typename RangeType<PositionType>::Position RangeType<PositionType>::getStart() const                          { return start; }
template<typename PositionType> inline constexpr typename RangeType<PositionType>::Position RangeType<PositionType>::getEnd() const                            { return end; }
template<typename PositionType> inline constexpr typename RangeType<PositionType>::Duration RangeType<PositionType>::getLength() const                         { return end - start; }
template<typename PositionType> inline constexpr typename RangeType<PositionType>::Position RangeType<PositionType>::getCentre() const                         { return fromUnderlyingType<Position> ((toUnderlyingType (start) + toUnderlyingType (end)) * 0.5); }
template<typename PositionType> inline typename RangeType<PositionType>::Position RangeType<PositionType>::clipPosition (Position position) const    { return juce::jlimit (start, end, position); }
 
template<typename PositionType> inline bool RangeType<PositionType>::isEmpty() const                                          { return end <= start; }
template<typename PositionType> inline bool RangeType<PositionType>::overlaps (const RangeType& other) const                  { return other.start < end && start < other.end; }
template<typename PositionType> inline bool RangeType<PositionType>::contains (const RangeType& other) const                  { return other.start >= start && other.end <= end; }
template<typename PositionType> inline bool RangeType<PositionType>::intersects (const RangeType& other) const                { return other.start < end && start < other.end; }
 
template<typename PositionType> inline bool RangeType<PositionType>::contains (Position time) const                           { return time >= start && time < end; }
template<typename PositionType> inline bool RangeType<PositionType>::containsInclusive (Position time) const                  { return time >= start && time <= end; }
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::getUnionWith (RangeType o) const
{
    return { std::min (start, o.start),
             std::max (end, o.end) };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::getIntersectionWith (RangeType o) const
{
    auto newStart = std::max (start, o.start);
    return { newStart, std::max (newStart, std::min (end, o.end)) };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::rescaled (Position anchorTime, double factor) const
{
    jassert (factor > 0);
    return { anchorTime + fromUnderlyingType<Duration> (toUnderlyingType (start - anchorTime) * factor),
             anchorTime + fromUnderlyingType<Duration> (toUnderlyingType (end   - anchorTime) * factor) };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::constrainRange (RangeType rangeToConstrain) const
{
    auto otherLen = rangeToConstrain.getLength();
 
    return getLength() <= otherLen
            ? *this
            : rangeToConstrain.movedToStartAt (juce::jlimit (start, end - otherLen,
                                                             rangeToConstrain.getStart()));
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::expanded (Duration amount) const
{
    jassert (amount >= Duration());
    return { start - amount, end + amount };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::reduced (Duration amount) const
{
    jassert (amount >= Duration());
    amount = std::min (amount, fromUnderlyingType<Duration> (toUnderlyingType (getLength()) / 2.0));
    return { start + amount, end - amount };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::movedToStartAt (Position newStart) const
{
    return { newStart, end + (newStart - start) };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::movedToEndAt (Position newEnd) const
{
    return { start + (newEnd - end), newEnd };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::withStart (Position newStart) const
{
    jassert (newStart <= end);
    return { newStart, std::max (end, newStart) };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::withEnd (Position newEnd) const
{
    jassert (newEnd >= start);
    return { std::min (start, newEnd), newEnd };
}
 
template<typename PositionType>
inline RangeType<PositionType> RangeType<PositionType>::withLength (Duration newLength) const
{
    jassert (newLength >= Duration());
    return { start, start + std::max (Duration(), newLength) };
}
 
 
template<typename PositionType>
inline void RangeType<PositionType>::checkInvariants() const
{
    jassert (end >= start);
}
 
inline juce::Range<int64_t> toSamples (TimeRange r, double sampleRate)
{
    return { toSamples (r.getStart(), sampleRate),
             toSamples (r.getEnd(), sampleRate) };
}
 
template<typename PositionType>
inline bool operator== (const RangeType<PositionType>& r1, const RangeType<PositionType>& r2)  { return r1.getStart() == r2.getStart() && r1.getEnd() == r2.getEnd(); }
template<typename PositionType>
inline bool operator!= (const RangeType<PositionType>& r1, const RangeType<PositionType>& r2)  { return ! operator== (r1, r2); }
 
template<typename PositionType>
inline RangeType<PositionType> operator+ (const RangeType<PositionType>& r, typename RangeType<PositionType>::Duration d)    { return RangeType<PositionType> (r.getStart() + d, r.getEnd() + d); }
template<typename PositionType>
inline RangeType<PositionType> operator- (const RangeType<PositionType>& r, typename RangeType<PositionType>::Duration d)    { return RangeType<PositionType> (r.getStart() - d, r.getEnd() - d); }
 
template<typename PositionType>
inline RangeType<PositionType> withEndExtended (RangeType<PositionType>& r, typename RangeType<PositionType>::Duration d)
{
    return r.withEnd (r.getEnd() + d);
}
 
template<typename RangeType,
         std::enable_if_t<std::is_same_v<TimeRange, RangeType>
                          || std::is_same_v<BeatRange, RangeType>,
                          bool> = true>
std::string to_string (RangeType range)
{
    return std::to_string (toUnderlyingType (range.getStart())) + ", "
            + std::to_string (toUnderlyingType (range.getEnd()));
}
 
inline std::ostream& operator<< (std::ostream& os, const TimeRange& r) { os << to_string (r); return os; }
inline std::ostream& operator<< (std::ostream& os, const BeatRange& r) { os << to_string (r); return os; }
 
}} // namespace tracktion
 
 
//==============================================================================
//==============================================================================
template<>
struct std::hash<tracktion::TimeRange>
{
    std::size_t operator()(const tracktion::TimeRange tr) const noexcept
    {
        std::size_t h1 = std::hash<double>{} (tr.getStart().inSeconds());
        std::size_t h2 = std::hash<double>{} (tr.getEnd().inSeconds());
 
        return tracktion::hash (h1, h2);
    }
};
 
template<>
struct std::hash<tracktion::BeatRange>
{
    std::size_t operator()(const tracktion::BeatRange tr) const noexcept
    {
        std::size_t h1 = std::hash<double>{} (tr.getStart().inBeats());
        std::size_t h2 = std::hash<double>{} (tr.getEnd().inBeats());
 
        return tracktion::hash (h1, h2);
    }
};