tracktion_Time.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 <chrono>
#include <cstdlib>
#include <juce_core/juce_core.h>
 
namespace tracktion { inline namespace core
{
 
struct TimeDuration;
struct BeatDuration;
 
//==============================================================================
//==============================================================================
struct TimePosition
{
    using DurationType = TimeDuration;
 
    constexpr TimePosition() = default;
 
    constexpr TimePosition (const TimePosition&) = default;
 
    template<typename Type>
    constexpr TimePosition (std::chrono::duration<Type>);
 
    template<typename T1, typename T2>
    constexpr TimePosition (std::chrono::duration<T1, T2>);
 
    constexpr TimePosition& operator= (const TimePosition&) = default;
 
    template<typename T>
    static constexpr TimePosition fromSeconds (T positionInSeconds);
 
    template<typename IntType>
    static constexpr TimePosition fromSamples (IntType numSamples, double sampleRate);
 
    constexpr double inSeconds() const;
 
private:
    double seconds = 0.0;
};
 
[[ nodiscard ]] constexpr TimePosition operator- (TimePosition);
 
[[ nodiscard ]] constexpr TimeDuration toDuration (TimePosition);
 
[[ nodiscard ]] constexpr int64_t toSamples (TimePosition, double sampleRate);
 
[[ nodiscard ]] TimePosition abs (TimePosition);
 
inline namespace literals
{
[[ nodiscard ]] constexpr TimePosition operator""_tp (long double seconds);
 
[[ nodiscard ]] constexpr TimePosition operator""_tp (unsigned long long seconds);
}
 
 
//==============================================================================
//==============================================================================
struct TimeDuration
{
    constexpr TimeDuration() = default;
 
    constexpr TimeDuration (const TimeDuration&) = default;
 
    template<typename Type>
    constexpr TimeDuration (std::chrono::duration<Type>);
 
    template<typename T1, typename T2>
    constexpr TimeDuration (std::chrono::duration<T1, T2>);
 
    constexpr TimeDuration& operator= (const TimeDuration&) = default;
 
    template<typename T>
    static constexpr TimeDuration fromSeconds (T positionInSeconds);
 
    template<typename IntType>
    static constexpr TimeDuration fromSamples (IntType numSamples, double sampleRate);
 
    constexpr double inSeconds() const;
 
private:
    double seconds = 0.0;
};
 
[[ nodiscard ]] constexpr TimeDuration operator- (TimeDuration);
 
[[ nodiscard ]] constexpr TimePosition toPosition (TimeDuration);
 
[[ nodiscard ]] constexpr int64_t toSamples (TimeDuration, double sampleRate);
 
[[ nodiscard ]] TimeDuration abs (TimeDuration);
 
inline namespace literals
{
[[ nodiscard ]] constexpr TimeDuration operator""_td (long double seconds);
 
[[ nodiscard ]] constexpr TimeDuration operator""_td (unsigned long long seconds);
}
 
//==============================================================================
[[ nodiscard ]] constexpr TimeDuration operator+ (const TimeDuration&, const TimeDuration&);
 
template<typename Type>
[[ nodiscard ]] constexpr TimeDuration operator+ (const TimeDuration&, std::chrono::duration<Type>);
 
[[ nodiscard ]] constexpr TimePosition operator+ (const TimePosition&, const TimeDuration&);
 
template<typename Type>
[[ nodiscard ]] constexpr TimePosition operator+ (const TimePosition&, std::chrono::duration<Type>);
 
[[ nodiscard ]] constexpr TimeDuration operator- (const TimePosition&, const TimePosition&);
 
[[ nodiscard ]] constexpr TimeDuration operator- (const TimeDuration&, const TimeDuration&);
 
template<typename Type>
[[ nodiscard ]] constexpr TimeDuration operator- (const TimeDuration&, std::chrono::duration<Type>);
 
[[ nodiscard ]] constexpr TimePosition operator- (const TimePosition&, const TimeDuration&);
 
template<typename Type>
[[ nodiscard ]] constexpr TimePosition operator- (const TimePosition&, std::chrono::duration<Type>);
 
[[ nodiscard ]] constexpr TimePosition operator* (const TimePosition&, double);
 
[[ nodiscard ]] constexpr TimePosition operator/ (const TimePosition&, double);
 
[[ nodiscard ]] constexpr TimeDuration operator* (const TimeDuration&, double);
 
[[ nodiscard ]] constexpr TimeDuration operator/ (const TimeDuration&, double);
 
[[ nodiscard ]] constexpr double operator/ (const TimePosition&, const TimeDuration&);
 
[[ nodiscard ]] constexpr double operator/ (const TimeDuration&, const TimeDuration&);
 
//==============================================================================
[[ nodiscard ]] constexpr bool operator== (const TimePosition&, const TimePosition&);
 
[[ nodiscard ]] constexpr bool operator!= (const TimePosition&, const TimePosition&);
 
[[ nodiscard ]] constexpr bool operator== (const TimeDuration&, const TimeDuration&);
 
[[ nodiscard ]] constexpr bool operator!= (const TimeDuration&, const TimeDuration&);
 
[[ nodiscard ]] constexpr bool operator< (const TimePosition&, const TimePosition&);
 
[[ nodiscard ]] constexpr bool operator<= (const TimePosition&, const TimePosition&);
 
[[ nodiscard ]] constexpr bool operator> (const TimePosition&, const TimePosition&);
 
[[ nodiscard ]] constexpr bool operator>= (const TimePosition&, const TimePosition&);
 
[[ nodiscard ]] constexpr bool operator< (const TimeDuration&, const TimeDuration&);
 
[[ nodiscard ]] constexpr bool operator<= (const TimeDuration&, const TimeDuration&);
 
[[ nodiscard ]] constexpr bool operator> (const TimeDuration&, const TimeDuration&);
 
[[ nodiscard ]] constexpr bool operator>= (const TimeDuration&, const TimeDuration&);
 
 
//==============================================================================
//==============================================================================
struct BeatPosition
{
    using DurationType = BeatDuration;
 
    constexpr BeatPosition() = default;
 
    constexpr BeatPosition (const BeatPosition&) = default;
 
    constexpr BeatPosition& operator= (const BeatPosition&) = default;
 
    template<typename T>
    static constexpr BeatPosition fromBeats (T positionInBeats);
 
    constexpr double inBeats() const;
 
private:
    double numBeats = 0.0;
};
 
[[ nodiscard ]] constexpr BeatPosition operator- (BeatPosition);
 
[[ nodiscard ]] constexpr BeatDuration toDuration (BeatPosition);
 
[[ nodiscard ]] BeatPosition roundToNearestBeat (BeatPosition);
 
[[ nodiscard ]] BeatPosition abs (BeatPosition);
 
inline namespace literals
{
[[ nodiscard ]] constexpr BeatPosition operator""_bp (long double beats);
 
[[ nodiscard ]] constexpr BeatPosition operator""_bp (unsigned long long beats);
}
 
//==============================================================================
//==============================================================================
struct BeatDuration
{
    constexpr BeatDuration() = default;
 
    constexpr BeatDuration (const BeatDuration&) = default;
 
    constexpr BeatDuration& operator= (const BeatDuration&) = default;
 
    template<typename T>
    static constexpr BeatDuration fromBeats (T durationInBeats);
 
    constexpr double inBeats() const;
 
private:
    double numBeats = 0.0;
};
 
[[ nodiscard ]] constexpr BeatDuration operator- (BeatDuration);
 
[[ nodiscard ]] constexpr BeatPosition toPosition (BeatDuration);
 
[[ nodiscard ]] BeatDuration roundToNearestBeat (BeatDuration);
 
[[ nodiscard ]] BeatDuration abs (BeatDuration);
 
inline namespace literals
{
[[ nodiscard ]] constexpr BeatDuration operator""_bd (long double beats);
 
[[ nodiscard ]] constexpr BeatDuration operator""_bd (unsigned long long beats);
}
 
//==============================================================================
[[ nodiscard ]] constexpr BeatDuration operator+ (const BeatDuration&, const BeatDuration&);
 
[[ nodiscard ]] constexpr BeatPosition operator+ (const BeatPosition&, const BeatDuration&);
 
[[ nodiscard ]] constexpr BeatDuration operator- (const BeatPosition&, const BeatPosition&);
 
[[ nodiscard ]] constexpr BeatDuration operator- (const BeatDuration&, const BeatDuration&);
 
[[ nodiscard ]] constexpr BeatPosition operator- (const BeatPosition&, const BeatDuration&);
 
template<typename Type>
[[ nodiscard ]] constexpr BeatPosition operator* (const BeatPosition&, Type);
 
[[ nodiscard ]] constexpr BeatPosition operator/ (const BeatPosition&, double);
 
template<typename Type>
[[ nodiscard ]] constexpr BeatDuration operator* (const BeatDuration&, Type);
 
[[ nodiscard ]] constexpr BeatDuration operator/ (const BeatDuration&, double);
 
[[ nodiscard ]] constexpr double operator/ (const BeatPosition&, const BeatDuration&);
 
[[ nodiscard ]] constexpr double operator/ (const BeatDuration&, const BeatDuration&);
 
//==============================================================================
[[ nodiscard ]] constexpr bool operator== (const BeatPosition&, const BeatPosition&);
 
[[ nodiscard ]] constexpr bool operator!= (const BeatPosition&, const BeatPosition&);
 
[[ nodiscard ]] constexpr bool operator== (const BeatDuration&, const BeatDuration&);
 
[[ nodiscard ]] constexpr bool operator!= (const BeatDuration&, const BeatDuration&);
 
[[ nodiscard ]] constexpr bool operator< (const BeatPosition&, const BeatPosition&);
 
[[ nodiscard ]] constexpr bool operator<= (const BeatPosition&, const BeatPosition&);
 
[[ nodiscard ]] constexpr bool operator> (const BeatPosition&, const BeatPosition&);
 
[[ nodiscard ]] constexpr bool operator>= (const BeatPosition&, const BeatPosition&);
 
[[ nodiscard ]] constexpr bool operator< (const BeatDuration&, const BeatDuration&);
 
[[ nodiscard ]] constexpr bool operator<= (const BeatDuration&, const BeatDuration&);
 
[[ nodiscard ]] constexpr bool operator> (const BeatDuration&, const BeatDuration&);
 
[[ nodiscard ]] constexpr bool operator>= (const BeatDuration&, const BeatDuration&);
 
 
//==============================================================================
//        _        _           _  _
//     __| |  ___ | |_   __ _ (_)| | ___
//    / _` | / _ \| __| / _` || || |/ __|
//   | (_| ||  __/| |_ | (_| || || |\__ \ _  _  _
//    \__,_| \___| \__| \__,_||_||_||___/(_)(_)(_)
//
//   Code beyond this point is implementation detail...
//
//==============================================================================
 
template<typename Type>
inline constexpr TimePosition::TimePosition (std::chrono::duration<Type> duration)
    : seconds (std::chrono::duration<double> (duration).count())
{
}
 
template<typename T1, typename T2>
inline constexpr TimePosition::TimePosition (std::chrono::duration<T1, T2> duration)
    : seconds (std::chrono::duration<double> (duration).count())
{
}
 
template<typename T>
inline constexpr TimePosition TimePosition::fromSeconds (T positionInSeconds)
{
    TimePosition pos;
    pos.seconds = static_cast<double> (positionInSeconds);
    return pos;
}
 
template<typename IntType>
inline constexpr TimePosition TimePosition::fromSamples (IntType samplePosition, double sampleRate)
{
    return TimePosition::fromSeconds (samplePosition / sampleRate);
}
 
inline constexpr double TimePosition::inSeconds() const
{
    return seconds;
}
 
inline constexpr TimePosition operator- (TimePosition t)
{
    return TimePosition::fromSeconds (-t.inSeconds());
}
 
inline constexpr TimeDuration toDuration (TimePosition t)
{
    return TimeDuration::fromSeconds (t.inSeconds());
}
 
inline constexpr int64_t toSamples (TimePosition p, double sampleRate)
{
    return static_cast<int64_t> ((p.inSeconds() * sampleRate)
                                 + (p.inSeconds() >= 0.0 ? 0.5 : -0.5));
}
 
inline TimePosition abs (TimePosition t)
{
    return TimePosition::fromSeconds (std::abs (t.inSeconds()));
}
 
inline namespace literals
{
inline constexpr TimePosition operator""_tp (long double seconds)
{
    return TimePosition::fromSeconds (seconds);
}
 
inline constexpr TimePosition operator""_tp (unsigned long long seconds)
{
    return TimePosition::fromSeconds (seconds);
}
}
 
//==============================================================================
template<typename Type>
inline constexpr TimeDuration::TimeDuration (std::chrono::duration<Type> duration)
    : seconds (std::chrono::duration<double> (duration).count())
{
}
 
template<typename T1, typename T2>
inline constexpr TimeDuration::TimeDuration (std::chrono::duration<T1, T2> duration)
    : seconds (std::chrono::duration<double> (duration).count())
{
}
 
template<typename T>
inline constexpr TimeDuration TimeDuration::fromSeconds (T positionInSeconds)
{
    TimeDuration pos;
    pos.seconds = static_cast<double> (positionInSeconds);
    return pos;
}
 
template<typename IntType>
inline constexpr TimeDuration TimeDuration::fromSamples (IntType samplePosition, double sampleRate)
{
    return TimeDuration::fromSeconds (samplePosition / sampleRate);
}
 
inline constexpr double TimeDuration::inSeconds() const
{
    return seconds;
}
 
inline constexpr TimeDuration operator- (TimeDuration t)
{
    return TimeDuration::fromSeconds (-t.inSeconds());
}
 
inline constexpr TimePosition toPosition (TimeDuration t)
{
    return TimePosition::fromSeconds (t.inSeconds());
}
 
inline constexpr int64_t toSamples (TimeDuration p, double sampleRate)
{
    return static_cast<int64_t> ((p.inSeconds() * sampleRate)
                                 + (p.inSeconds() >= 0.0 ? 0.5 : -0.5));
}
 
inline TimeDuration abs (TimeDuration t)
{
    return TimeDuration::fromSeconds (std::abs (t.inSeconds()));
}
 
inline namespace literals
{
inline constexpr TimeDuration operator""_td (long double seconds)
{
    return TimeDuration::fromSeconds (seconds);
}
 
inline constexpr TimeDuration operator""_td (unsigned long long seconds)
{
    return TimeDuration::fromSeconds (seconds);
}
}
 
//==============================================================================
inline constexpr TimeDuration operator+ (const TimeDuration& t1, const TimeDuration& t2)
{
    return TimeDuration::fromSeconds (t1.inSeconds() + t2.inSeconds());
}
 
inline constexpr TimePosition operator+ (const TimePosition& t1, const TimeDuration& t2)
{
    return TimePosition::fromSeconds (t1.inSeconds() + t2.inSeconds());
}
 
inline constexpr TimeDuration operator- (const TimePosition& t1, const TimePosition& t2)
{
    return TimeDuration::fromSeconds (t1.inSeconds() - t2.inSeconds());
}
 
inline constexpr TimeDuration operator- (const TimeDuration& t1, const TimeDuration& t2)
{
    return TimeDuration::fromSeconds (t1.inSeconds() - t2.inSeconds());
}
 
inline constexpr TimePosition operator- (const TimePosition& t1, const TimeDuration& t2)
{
    return TimePosition::fromSeconds (t1.inSeconds() - t2.inSeconds());
}
 
template<typename Type>
inline constexpr TimeDuration operator+ (const TimeDuration& t1, std::chrono::duration<Type> t2)
{
    return TimeDuration::fromSeconds (t1.inSeconds() + std::chrono::duration<double> (t2).count());
}
 
template<typename Type>
inline constexpr TimePosition operator+ (const TimePosition& t1, std::chrono::duration<Type> t2)
{
    return TimePosition::fromSeconds (t1.inSeconds() + std::chrono::duration<double> (t2).count());
}
 
template<typename Type>
inline constexpr TimeDuration operator- (const TimeDuration& t1, std::chrono::duration<Type> t2)
{
    return TimeDuration::fromSeconds (t1.inSeconds() - std::chrono::duration<double> (t2).count());
}
 
template<typename Type>
inline constexpr TimePosition operator- (const TimePosition& t1, std::chrono::duration<Type> t2)
{
    return TimePosition::fromSeconds (t1.inSeconds() - std::chrono::duration<double> (t2).count());
}
 
inline constexpr TimePosition operator* (const TimePosition& t, double ammount)
{
    return TimePosition::fromSeconds (t.inSeconds() * ammount);
}
 
inline constexpr TimePosition operator/ (const TimePosition& t, double ammount)
{
    return TimePosition::fromSeconds (t.inSeconds() / ammount);
}
 
inline constexpr TimeDuration operator* (const TimeDuration& t, double ammount)
{
    return TimeDuration::fromSeconds (t.inSeconds() * ammount);
}
 
inline constexpr TimeDuration operator/ (const TimeDuration& t, double ammount)
{
    return TimeDuration::fromSeconds (t.inSeconds() / ammount);
}
 
inline constexpr double operator/ (const TimePosition& t1, const TimeDuration& t2)
{
    return t1.inSeconds() / t2.inSeconds();
}
 
inline constexpr double operator/ (const TimeDuration& t1, const TimeDuration& t2)
{
    return t1.inSeconds() / t2.inSeconds();
}
 
inline constexpr bool operator== (const TimePosition& t1, const TimePosition& t2)   { return t1.inSeconds() == t2.inSeconds(); }
inline constexpr bool operator!= (const TimePosition& t1, const TimePosition& t2)   { return ! (t1 == t2); }
 
inline constexpr bool operator== (const TimeDuration& t1, const TimeDuration& t2)   { return t1.inSeconds() == t2.inSeconds(); }
inline constexpr bool operator!= (const TimeDuration& t1, const TimeDuration& t2)   { return ! (t1 == t2); }
 
inline constexpr bool operator<     (const TimePosition& t1, const TimePosition& t2)    { return t1.inSeconds() < t2.inSeconds(); }
inline constexpr bool operator<=    (const TimePosition& t1, const TimePosition& t2)    { return t1.inSeconds() <= t2.inSeconds(); }
inline constexpr bool operator>     (const TimePosition& t1, const TimePosition& t2)    { return t1.inSeconds() > t2.inSeconds(); }
inline constexpr bool operator>=    (const TimePosition& t1, const TimePosition& t2)    { return t1.inSeconds() >= t2.inSeconds(); }
 
inline constexpr bool operator<     (const TimeDuration& t1, const TimeDuration& t2)    { return t1.inSeconds() < t2.inSeconds(); }
inline constexpr bool operator<=    (const TimeDuration& t1, const TimeDuration& t2)    { return t1.inSeconds() <= t2.inSeconds(); }
inline constexpr bool operator>     (const TimeDuration& t1, const TimeDuration& t2)    { return t1.inSeconds() > t2.inSeconds(); }
inline constexpr bool operator>=    (const TimeDuration& t1, const TimeDuration& t2)    { return t1.inSeconds() >= t2.inSeconds(); }
 
//==============================================================================
template<typename T>
inline constexpr BeatPosition BeatPosition::fromBeats (T positionInBeats)
{
    BeatPosition pos;
    pos.numBeats = static_cast<double> (positionInBeats);
    return pos;
}
 
inline constexpr double BeatPosition::inBeats() const
{
    return numBeats;
}
 
inline BeatPosition abs (BeatPosition t)
{
    return BeatPosition::fromBeats (std::abs (t.inBeats()));
}
 
inline namespace literals
{
inline constexpr BeatPosition operator""_bp (long double beats)
{
    return BeatPosition::fromBeats (beats);
}
 
inline constexpr BeatPosition operator""_bp (unsigned long long beats)
{
    return BeatPosition::fromBeats (beats);
}
}
 
 
//==============================================================================
//==============================================================================
template<typename T>
inline constexpr BeatDuration BeatDuration::fromBeats (T durationInBeats)
{
    BeatDuration pos;
    pos.numBeats = static_cast<double> (durationInBeats);
    return pos;
}
 
inline constexpr double BeatDuration::inBeats() const
{
    return numBeats;
}
 
inline constexpr BeatDuration toDuration (BeatPosition t)
{
    return BeatDuration::fromBeats (t.inBeats());
}
 
inline BeatPosition roundToNearestBeat (BeatPosition t)
{
    return BeatPosition::fromBeats (juce::roundToInt (t.inBeats()));
}
 
inline BeatDuration roundToNearestBeat (BeatDuration t)
{
    return BeatDuration::fromBeats (juce::roundToInt (t.inBeats()));
}
 
inline BeatDuration abs (BeatDuration t)
{
    return BeatDuration::fromBeats (std::abs (t.inBeats()));
}
 
inline namespace literals
{
inline constexpr BeatDuration operator""_bd (long double beats)
{
    return BeatDuration::fromBeats (beats);
}
 
inline constexpr BeatDuration operator""_bd (unsigned long long beats)
{
    return BeatDuration::fromBeats (beats);
}
}
 
constexpr BeatPosition toPosition (BeatDuration t)
{
    return BeatPosition::fromBeats (t.inBeats());
}
 
constexpr BeatPosition operator- (BeatPosition t)
{
    return BeatPosition::fromBeats (-t.inBeats());
}
 
constexpr BeatDuration operator- (BeatDuration t)
{
    return BeatDuration::fromBeats (-t.inBeats());
}
 
//==============================================================================
inline constexpr BeatDuration operator+ (const BeatDuration& t1, const BeatDuration& t2)
{
    return BeatDuration::fromBeats (t1.inBeats() + t2.inBeats());
}
 
inline constexpr BeatPosition operator+ (const BeatPosition& t1, const BeatDuration& t2)
{
    return BeatPosition::fromBeats (t1.inBeats() + t2.inBeats());
}
 
inline constexpr BeatDuration operator- (const BeatPosition& t1, const BeatPosition& t2)
{
    return BeatDuration::fromBeats (t1.inBeats() - t2.inBeats());
}
 
inline constexpr BeatDuration operator- (const BeatDuration& t1, const BeatDuration& t2)
{
    return BeatDuration::fromBeats (t1.inBeats() - t2.inBeats());
}
 
inline constexpr BeatPosition operator- (const BeatPosition& t1, const BeatDuration& t2)
{
    return BeatPosition::fromBeats (t1.inBeats() - t2.inBeats());
}
 
template<typename Type>
inline constexpr BeatPosition operator* (const BeatPosition& t, Type ammount)
{
    return BeatPosition::fromBeats (t.inBeats() * static_cast<double> (ammount));
}
 
inline constexpr BeatPosition operator/ (const BeatPosition& t, double ammount)
{
    return BeatPosition::fromBeats (t.inBeats() / ammount);
}
 
template<typename Type>
inline constexpr BeatDuration operator* (const BeatDuration& t, Type ammount)
{
    return BeatDuration::fromBeats (t.inBeats() * static_cast<double> (ammount));
}
 
inline constexpr BeatDuration operator/ (const BeatDuration& t, double ammount)
{
    return BeatDuration::fromBeats (t.inBeats() / ammount);
}
 
inline constexpr double operator/ (const BeatPosition& t1, const BeatDuration& t2)
{
    return t1.inBeats() / t2.inBeats();
}
 
inline constexpr double operator/ (const BeatDuration& t1, const BeatDuration& t2)
{
    return t1.inBeats() / t2.inBeats();
}
 
inline constexpr bool operator== (const BeatPosition& t1, const BeatPosition& t2)   { return t1.inBeats() == t2.inBeats(); }
inline constexpr bool operator!= (const BeatPosition& t1, const BeatPosition& t2)   { return ! (t1 == t2); }
 
inline constexpr bool operator== (const BeatDuration& t1, const BeatDuration& t2)   { return t1.inBeats() == t2.inBeats(); }
inline constexpr bool operator!= (const BeatDuration& t1, const BeatDuration& t2)   { return ! (t1 == t2); }
 
inline constexpr bool operator<     (const BeatPosition& t1, const BeatPosition& t2)    { return t1.inBeats() < t2.inBeats(); }
inline constexpr bool operator<=    (const BeatPosition& t1, const BeatPosition& t2)    { return t1.inBeats() <= t2.inBeats(); }
inline constexpr bool operator>     (const BeatPosition& t1, const BeatPosition& t2)    { return t1.inBeats() > t2.inBeats(); }
inline constexpr bool operator>=    (const BeatPosition& t1, const BeatPosition& t2)    { return t1.inBeats() >= t2.inBeats(); }
 
inline constexpr bool operator<     (const BeatDuration& t1, const BeatDuration& t2)    { return t1.inBeats() < t2.inBeats(); }
inline constexpr bool operator<=    (const BeatDuration& t1, const BeatDuration& t2)    { return t1.inBeats() <= t2.inBeats(); }
inline constexpr bool operator>     (const BeatDuration& t1, const BeatDuration& t2)    { return t1.inBeats() > t2.inBeats(); }
inline constexpr bool operator>=    (const BeatDuration& t1, const BeatDuration& t2)    { return t1.inBeats() >= t2.inBeats(); }
 
inline juce::String& operator<< (juce::String& s, TimeDuration d)  { return s << juce::String (d.inSeconds()); }
inline juce::String& operator<< (juce::String& s, TimePosition p)  { return s << juce::String (p.inSeconds()); }
inline juce::String& operator<< (juce::String& s, BeatDuration d)  { return s << juce::String (d.inBeats()); }
inline juce::String& operator<< (juce::String& s, BeatPosition p)  { return s << juce::String (p.inBeats()); }
 
inline std::ostream& operator<< (std::ostream& os, const TimeDuration& v) { os << v.inSeconds(); return os; }
inline std::ostream& operator<< (std::ostream& os, const TimePosition& v) { os << v.inSeconds(); return os; }
inline std::ostream& operator<< (std::ostream& os, const BeatDuration& v) { os << v.inBeats(); return os; }
inline std::ostream& operator<< (std::ostream& os, const BeatPosition& v) { os << v.inBeats(); return os; }
 
}} // namespace tracktion
 
 
//==============================================================================
//==============================================================================
template<>
struct std::hash<tracktion::TimePosition>
{
    std::size_t operator()(const tracktion::TimePosition t) const noexcept
    {
        return std::hash<double>{} (t.inSeconds());
    }
};
 
template<>
struct std::hash<tracktion::TimeDuration>
{
    std::size_t operator()(const tracktion::TimeDuration t) const noexcept
    {
        return std::hash<double>{} (t.inSeconds());
    }
};
 
template<>
struct std::hash<tracktion::BeatPosition>
{
    std::size_t operator()(const tracktion::BeatPosition t) const noexcept
    {
        return std::hash<double>{} (t.inBeats());
    }
};
 
template<>
struct std::hash<tracktion::BeatDuration>
{
    std::size_t operator()(const tracktion::BeatDuration t) const noexcept
    {
        return std::hash<double>{} (t.inBeats());
    }
};