NoteName.h

#ifndef MCC_PITCH_NOTE_NAME_H
#define MCC_PITCH_NOTE_NAME_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
#include <Foundation/Math/Arithmetic.h>
 
#include <MCC/Pitch/Accidental.h>
#include <MCC/Pitch/PitchClass.h>
#include <MCC/Pitch/Letter.h>
 
namespace MCC {

class NoteName {
    static constexpr uint8_t InvalidLetter = 0xFF;
 
    uint8_t _letter;
    MCC::Accidental _accidental;
 
public:
    constexpr NoteName() noexcept
        : _letter(InvalidLetter), _accidental(MCC::Accidental::Invalid()) {}

    constexpr NoteName(MCC::Letter letter, MCC::Accidental accidental) noexcept
        : _letter(IsSpellable(letter, accidental)
              ? static_cast<uint8_t>(letter)
              : InvalidLetter),
          _accidental(IsSpellable(letter, accidental)
              ? accidental
              : MCC::Accidental::Invalid()) {}

    constexpr explicit NoteName(MCC::Letter letter) noexcept
        : NoteName(letter, MCC::Accidental::Natural()) {}

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

    constexpr bool IsValid() const noexcept { return _letter != InvalidLetter; }

    constexpr MCC::Letter Letter() const noexcept {
        return IsValid() ? static_cast<MCC::Letter>(_letter) : MCC::Letter::C;
    }

    constexpr MCC::Accidental Accidental() const noexcept { return _accidental; }

    MCC_CONSTEXPR14 MCC::PitchClass PitchClass() const noexcept {
        if (!IsValid()) {
            return MCC::PitchClass::Invalid();
        }
        return MCC::PitchClass(Foundation::Math::FloorMod(
            NaturalSemitone(Letter()) + _accidental.Semitones(),
            MCC::PitchClass::Count));
    }

    MCC_CONSTEXPR14 NoteName MovedDiatonically(int32_t steps) const noexcept {
        if (!IsValid()) {
            return Invalid();
        }
        return NoteName(MoveLetter(Letter(), steps), _accidental);
    }

    MCC_CONSTEXPR14 NoteName Altered(int32_t semitones) const noexcept {
        if (!IsValid()) {
            return Invalid();
        }
        return NoteName(Letter(), _accidental.Altered(semitones));
    }

    friend constexpr bool operator==(NoteName a, NoteName b) noexcept {
        return a._letter == b._letter && a._accidental == b._accidental;
    }
 
    friend constexpr bool operator!=(NoteName a, NoteName b) noexcept {
        return !(a == b);
    }

    friend constexpr bool operator<(NoteName a, NoteName b) noexcept {
        return (a._letter != b._letter)
            ? a._letter < b._letter
            : a._accidental < b._accidental;
    }
 
    friend constexpr bool operator>(NoteName a, NoteName b) noexcept {
        return b < a;
    }
 
    friend constexpr bool operator<=(NoteName a, NoteName b) noexcept {
        return !(b < a);
    }
 
    friend constexpr bool operator>=(NoteName a, NoteName b) noexcept {
        return !(a < b);
    }
 
private:
    static constexpr bool IsSpellable(
        MCC::Letter letter,
        MCC::Accidental accidental
    ) noexcept {
        return Detail::IsLetter(letter) && accidental.IsValid();
    }
};

constexpr bool IsEnharmonic(NoteName a, NoteName b) noexcept {
    return a.IsValid() && b.IsValid() && a.PitchClass() == b.PitchClass();
}
 
} // namespace MCC
 
#endif // MCC_PITCH_NOTE_NAME_H