Pitch.h

#ifndef MCC_PITCH_PITCH_H
#define MCC_PITCH_PITCH_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/ChromaticIndex.h>
#include <MCC/Pitch/Letter.h>
#include <MCC/Pitch/NoteName.h>
 
namespace MCC {

class Pitch {
public:
    static constexpr int8_t MinimumOctave = -128;

    static constexpr int8_t MaximumOctave = 127;

    static constexpr int16_t InvalidDiatonicIndex = 32767;
 
private:
    MCC::NoteName _noteName;
    int8_t _octave;
 
public:
    constexpr Pitch() noexcept : _noteName(), _octave(0) {}

    constexpr Pitch(MCC::NoteName noteName, int32_t octave) noexcept
        : _noteName(IsWritable(noteName, octave)
              ? noteName
              : MCC::NoteName::Invalid()),
          _octave(IsWritable(noteName, octave)
              ? static_cast<int8_t>(octave)
              : static_cast<int8_t>(0)) {}

    constexpr Pitch(MCC::Letter letter, MCC::Accidental accidental,
                    int32_t octave) noexcept
        : Pitch(MCC::NoteName(letter, accidental), octave) {}

    constexpr Pitch(MCC::Letter letter, int32_t octave) noexcept
        : Pitch(MCC::NoteName(letter), octave) {}

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

    constexpr bool IsValid() const noexcept { return _noteName.IsValid(); }

    constexpr MCC::NoteName NoteName() const noexcept { return _noteName; }

    constexpr MCC::Letter Letter() const noexcept { return _noteName.Letter(); }

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

    constexpr int8_t Octave() const noexcept { return _octave; }

    MCC_CONSTEXPR14 int16_t DiatonicIndex() const noexcept {
        if (!IsValid()) {
            return InvalidDiatonicIndex;
        }
        return static_cast<int16_t>(
            _octave * LetterCount + MCC::DiatonicIndex(Letter()));
    }

    MCC_CONSTEXPR14 MCC::ChromaticIndex ChromaticIndex() const noexcept {
        if (!IsValid()) {
            return MCC::ChromaticIndex::Invalid();
        }
        return MCC::ChromaticIndex(
            (static_cast<int32_t>(_octave) + 1) * MCC::PitchClass::Count +
            NaturalSemitone(Letter()) + Accidental().Semitones());
    }

    MCC_CONSTEXPR14 MCC::PitchClass PitchClass() const noexcept {
        return _noteName.PitchClass();
    }

    MCC_CONSTEXPR14 Pitch MovedDiatonically(int32_t steps) const noexcept {
        if (!IsValid() || steps < -2 * DiatonicSpan || steps > 2 * DiatonicSpan) {
            return Invalid();
        }
        const int32_t index = DiatonicIndex() + steps;
        return Pitch(
            MCC::NoteName(
                static_cast<MCC::Letter>(
                    Foundation::Math::FloorMod(index, LetterCount)),
                Accidental()),
            Foundation::Math::FloorDiv(index, LetterCount));
    }

    MCC_CONSTEXPR14 Pitch Altered(int32_t semitones) const noexcept {
        if (!IsValid()) {
            return Invalid();
        }
        return Pitch(_noteName.Altered(semitones), _octave);
    }

    MCC_CONSTEXPR14 Pitch MovedByOctaves(int32_t octaves) const noexcept {
        if (!IsValid() ||
            octaves < MinimumOctave - MaximumOctave ||
            octaves > MaximumOctave - MinimumOctave) {
            return Invalid();
        }
        return Pitch(_noteName, _octave + octaves);
    }

    friend constexpr bool operator==(Pitch a, Pitch b) noexcept {
        return a._noteName == b._noteName && a._octave == b._octave;
    }
 
    friend constexpr bool operator!=(Pitch a, Pitch b) noexcept {
        return !(a == b);
    }

    friend MCC_CONSTEXPR14 bool operator<(Pitch a, Pitch b) noexcept {
        if (!a.IsValid() || !b.IsValid()) {
            return a.IsValid() && !b.IsValid();
        }
        return (a._octave != b._octave)
            ? a._octave < b._octave
            : a._noteName < b._noteName;
    }
 
    friend MCC_CONSTEXPR14 bool operator>(Pitch a, Pitch b) noexcept {
        return b < a;
    }
 
    friend MCC_CONSTEXPR14 bool operator<=(Pitch a, Pitch b) noexcept {
        return !(b < a);
    }
 
    friend MCC_CONSTEXPR14 bool operator>=(Pitch a, Pitch b) noexcept {
        return !(a < b);
    }
 
private:
    // Number of diatonic positions between the lowest and highest pitch.
    static constexpr int32_t DiatonicSpan =
        (static_cast<int32_t>(MaximumOctave) - MinimumOctave + 1) * LetterCount;
 
    static constexpr bool IsWritable(MCC::NoteName noteName,
                                     int32_t octave) noexcept {
        return noteName.IsValid() &&
            octave >= MinimumOctave && octave <= MaximumOctave;
    }
};

constexpr bool IsEnharmonic(Pitch a, Pitch b) noexcept {
    return a.IsValid() && b.IsValid() && a.ChromaticIndex() == b.ChromaticIndex();
}

MCC_CONSTEXPR14 bool IsLowerThan(Pitch a, Pitch b) noexcept {
    if (!a.IsValid() || !b.IsValid()) {
        return a.IsValid() && !b.IsValid();
    }
    return (a.ChromaticIndex() != b.ChromaticIndex())
        ? a.ChromaticIndex() < b.ChromaticIndex()
        : a < b;
}
 
} // namespace MCC
 
#endif // MCC_PITCH_PITCH_H