NoteValue.h

#ifndef MCC_RHYTHM_NOTE_VALUE_H
#define MCC_RHYTHM_NOTE_VALUE_H
 
#include <stdint.h>
 
#include <MCC_BuildSettings.h>
 
namespace MCC {

class NoteValue {
    static constexpr uint8_t InvalidBaseExponent = 0xFFu;
    static constexpr uint8_t MaximumBaseExponent = 8u;
 
    uint8_t _baseExponent;
    uint8_t _dots;
 
    static constexpr bool IsDotCountValid(int32_t dots) noexcept {
        return dots >= 0 && dots <= 4;
    }
 
    constexpr NoteValue(uint8_t baseExponent, int32_t dots) noexcept
        : _baseExponent(baseExponent <= MaximumBaseExponent && IsDotCountValid(dots)
              ? baseExponent
              : InvalidBaseExponent),
          _dots(baseExponent <= MaximumBaseExponent && IsDotCountValid(dots)
              ? static_cast<uint8_t>(dots)
              : 0u) {}
 
public:
    static constexpr uint8_t MaximumDots = 4u;

    static constexpr uint8_t InvalidDotCount = 0xFFu;

    constexpr NoteValue() noexcept : _baseExponent(InvalidBaseExponent), _dots(0u) {}

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

    static constexpr NoteValue Whole(int32_t dots = 0) noexcept {
        return NoteValue(0u, dots);
    }

    static constexpr NoteValue Half(int32_t dots = 0) noexcept {
        return NoteValue(1u, dots);
    }

    static constexpr NoteValue Quarter(int32_t dots = 0) noexcept {
        return NoteValue(2u, dots);
    }

    static constexpr NoteValue Eighth(int32_t dots = 0) noexcept {
        return NoteValue(3u, dots);
    }

    static constexpr NoteValue Sixteenth(int32_t dots = 0) noexcept {
        return NoteValue(4u, dots);
    }

    static constexpr NoteValue ThirtySecond(int32_t dots = 0) noexcept {
        return NoteValue(5u, dots);
    }

    static constexpr NoteValue SixtyFourth(int32_t dots = 0) noexcept {
        return NoteValue(6u, dots);
    }

    static constexpr NoteValue OneHundredTwentyEighth(int32_t dots = 0) noexcept {
        return NoteValue(7u, dots);
    }

    static constexpr NoteValue TwoHundredFiftySixth(int32_t dots = 0) noexcept {
        return NoteValue(8u, dots);
    }

    static MCC_CONSTEXPR14 NoteValue FromDenominator(
        int32_t baseDenominator, int32_t dots = 0) noexcept {
        switch (baseDenominator) {
            case 1: return Whole(dots);
            case 2: return Half(dots);
            case 4: return Quarter(dots);
            case 8: return Eighth(dots);
            case 16: return Sixteenth(dots);
            case 32: return ThirtySecond(dots);
            case 64: return SixtyFourth(dots);
            case 128: return OneHundredTwentyEighth(dots);
            case 256: return TwoHundredFiftySixth(dots);
            default: return Invalid();
        }
    }

    constexpr bool IsValid() const noexcept {
        return _baseExponent != InvalidBaseExponent;
    }

    constexpr bool IsDotted() const noexcept { return IsValid() && _dots != 0u; }

    constexpr uint16_t BaseDenominator() const noexcept {
        return IsValid()
            ? static_cast<uint16_t>(uint16_t(1u) << _baseExponent)
            : uint16_t(0u);
    }

    constexpr uint8_t DotCount() const noexcept {
        return IsValid() ? _dots : InvalidDotCount;
    }

    constexpr uint16_t Numerator() const noexcept {
        return IsValid()
            ? static_cast<uint16_t>((uint16_t(1u) << (_dots + 1u)) - 1u)
            : uint16_t(0u);
    }

    constexpr uint16_t Denominator() const noexcept {
        return IsValid()
            ? static_cast<uint16_t>(uint16_t(1u) << (_baseExponent + _dots))
            : uint16_t(0u);
    }

    constexpr NoteValue WithDots(int32_t dots) const noexcept {
        return IsValid() ? NoteValue(_baseExponent, dots) : Invalid();
    }

    friend constexpr bool operator==(NoteValue a, NoteValue b) noexcept {
        return a._baseExponent == b._baseExponent && a._dots == b._dots;
    }
 
    friend constexpr bool operator!=(NoteValue a, NoteValue b) noexcept {
        return !(a == b);
    }

    friend constexpr bool operator<(NoteValue a, NoteValue b) noexcept {
        return a.IsValid() != b.IsValid()
            ? a.IsValid()
            : (!a.IsValid()
                ? false
                : static_cast<uint32_t>(a.Numerator()) * b.Denominator()
                    < static_cast<uint32_t>(b.Numerator()) * a.Denominator());
    }
 
    friend constexpr bool operator>(NoteValue a, NoteValue b) noexcept {
        return b < a;
    }
 
    friend constexpr bool operator<=(NoteValue a, NoteValue b) noexcept {
        return !(b < a);
    }
 
    friend constexpr bool operator>=(NoteValue a, NoteValue b) noexcept {
        return !(a < b);
    }
};
 
} // namespace MCC
 
#endif // MCC_RHYTHM_NOTE_VALUE_H