Meter.h

#ifndef MCC_RHYTHM_METER_H
#define MCC_RHYTHM_METER_H
 
#include <stdint.h>
 
#include <MCC_BuildSettings.h>
#include <MCC/Rhythm/NoteValue.h>
 
namespace MCC {

enum class MeterKind : uint8_t {
    Simple = 0,
    Compound,
    Irregular,
    Invalid
};

class Meter {
    uint8_t _numerator;
    MCC::NoteValue _pulseValue;
 
    static constexpr bool IsUndotted(MCC::NoteValue value) noexcept {
        return value.IsValid() && value.DotCount() == 0u;
    }
 
    static constexpr bool LooksCompound(int32_t numerator) noexcept {
        return numerator >= 6 && numerator % 3 == 0;
    }
 
    static constexpr bool IsUsable(
        int32_t numerator, MCC::NoteValue pulseValue) noexcept {
        return numerator >= 1 && numerator <= 255 && IsUndotted(pulseValue) &&
            (!LooksCompound(numerator) || pulseValue.BaseDenominator() >= 2u);
    }
 
    static MCC_CONSTEXPR14 uint16_t GreatestCommonDivisor(
        uint16_t a, uint16_t b) noexcept {
        while (b != 0u) {
            const uint16_t remainder = static_cast<uint16_t>(a % b);
            a = b;
            b = remainder;
        }
        return a;
    }
 
public:
    constexpr Meter() noexcept : _numerator(0u), _pulseValue() {}

    MCC_CONSTEXPR14 Meter(int32_t numerator, int32_t denominator) noexcept
        : Meter(numerator, MCC::NoteValue::FromDenominator(denominator)) {}

    constexpr Meter(int32_t numerator, MCC::NoteValue pulseValue) noexcept
        : _numerator(IsUsable(numerator, pulseValue)
              ? static_cast<uint8_t>(numerator)
              : uint8_t(0u)),
          _pulseValue(IsUsable(numerator, pulseValue)
              ? pulseValue
              : MCC::NoteValue::Invalid()) {}

    static constexpr Meter Invalid() noexcept { return Meter(); }

    static MCC_CONSTEXPR14 Meter CommonTime() noexcept { return Meter(4, 4); }

    static MCC_CONSTEXPR14 Meter CutTime() noexcept { return Meter(2, 2); }

    static constexpr Meter Simple(
        int32_t beatCount,
        MCC::NoteValue beatValue = MCC::NoteValue::Quarter()) noexcept {
        return beatCount >= 1 && beatCount <= 4 && IsUndotted(beatValue)
            ? Meter(beatCount, beatValue)
            : Invalid();
    }

    static MCC_CONSTEXPR14 Meter Compound(
        int32_t beatCount,
        MCC::NoteValue beatValue = MCC::NoteValue::Quarter(1)) noexcept {
        if (beatCount < 2 || beatCount > 85 || !beatValue.IsValid() ||
            beatValue.DotCount() != 1u || beatValue.BaseDenominator() > 128u) {
            return Invalid();
        }
        return Meter(
            beatCount * 3,
            static_cast<int32_t>(beatValue.BaseDenominator()) * 2);
    }

    constexpr bool IsValid() const noexcept { return _numerator != 0u; }

    constexpr uint8_t Numerator() const noexcept { return _numerator; }

    constexpr uint16_t Denominator() const noexcept {
        return _pulseValue.BaseDenominator();
    }

    constexpr MCC::NoteValue PulseValue() const noexcept { return _pulseValue; }

    constexpr uint8_t PulseCount() const noexcept { return _numerator; }

    constexpr MeterKind Kind() const noexcept {
        return !IsValid() ? MeterKind::Invalid
            : (_numerator <= 4u ? MeterKind::Simple
                : (LooksCompound(_numerator)
                    ? MeterKind::Compound
                    : MeterKind::Irregular));
    }
 
    constexpr bool IsSimple() const noexcept { return Kind() == MeterKind::Simple; }
    constexpr bool IsCompound() const noexcept { return Kind() == MeterKind::Compound; }
    constexpr bool IsIrregular() const noexcept { return Kind() == MeterKind::Irregular; }

    constexpr uint8_t BeatCount() const noexcept {
        return IsSimple() ? _numerator
            : (IsCompound() ? static_cast<uint8_t>(_numerator / 3u) : 0u);
    }

    MCC_CONSTEXPR14 MCC::NoteValue BeatValue() const noexcept {
        if (IsSimple()) {
            return _pulseValue;
        }
        if (IsCompound()) {
            return MCC::NoteValue::FromDenominator(
                static_cast<int32_t>(Denominator() / 2u), 1);
        }
        return MCC::NoteValue::Invalid();
    }

    MCC_CONSTEXPR14 uint16_t MeasureNumerator() const noexcept {
        if (!IsValid()) {
            return 0u;
        }
        const uint16_t divisor = GreatestCommonDivisor(_numerator, Denominator());
        return static_cast<uint16_t>(_numerator / divisor);
    }

    MCC_CONSTEXPR14 uint16_t MeasureDenominator() const noexcept {
        if (!IsValid()) {
            return 0u;
        }
        const uint16_t divisor = GreatestCommonDivisor(_numerator, Denominator());
        return static_cast<uint16_t>(Denominator() / divisor);
    }

    friend constexpr bool operator==(Meter a, Meter b) noexcept {
        return a._numerator == b._numerator && a._pulseValue == b._pulseValue;
    }
 
    friend constexpr bool operator!=(Meter a, Meter b) noexcept {
        return !(a == b);
    }

    friend constexpr bool operator<(Meter a, Meter b) noexcept {
        return a.IsValid() != b.IsValid() ? a.IsValid()
            : (!a.IsValid() ? false
                : (a._numerator != b._numerator
                    ? a._numerator < b._numerator
                    : a.Denominator() < b.Denominator()));
    }
 
    friend constexpr bool operator>(Meter a, Meter b) noexcept { return b < a; }
    friend constexpr bool operator<=(Meter a, Meter b) noexcept { return !(b < a); }
    friend constexpr bool operator>=(Meter a, Meter b) noexcept { return !(a < b); }
};

constexpr bool HasSameMeasureDuration(Meter a, Meter b) noexcept {
    return a.IsValid() && b.IsValid() &&
        static_cast<uint32_t>(a.Numerator()) * b.Denominator() ==
        static_cast<uint32_t>(b.Numerator()) * a.Denominator();
}
 
} // namespace MCC
 
#endif // MCC_RHYTHM_METER_H