KeySignature.h

#ifndef MCC_KEY_KEY_SIGNATURE_H
#define MCC_KEY_KEY_SIGNATURE_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
#include <MCC/Pitch/Accidental.h>
#include <MCC/Pitch/Letter.h>
 
namespace MCC {

class KeySignature {
    static constexpr int8_t InvalidValue = -128;
 
    int8_t _fifths;
 
    // Position of a letter in the order of sharps: F C G D A E B.
    static constexpr int32_t SharpOrder(Letter letter) noexcept {
        return (DiatonicIndex(letter) * 2 + 1) % 7;
    }
 
public:
    constexpr KeySignature() noexcept : _fifths(InvalidValue) {}

    constexpr explicit KeySignature(int32_t fifths) noexcept
        : _fifths(fifths >= -7 && fifths <= 7 ? static_cast<int8_t>(fifths) : InvalidValue) {}

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

    constexpr bool IsValid() const noexcept { return _fifths != InvalidValue; }

    constexpr int8_t Fifths() const noexcept { return IsValid() ? _fifths : static_cast<int8_t>(0); }

    constexpr uint8_t Sharps() const noexcept {
        return static_cast<uint8_t>(Fifths() > 0 ? Fifths() : 0);
    }

    constexpr uint8_t Flats() const noexcept {
        return static_cast<uint8_t>(Fifths() < 0 ? -Fifths() : 0);
    }

    MCC_CONSTEXPR14 MCC::Accidental AccidentalOf(Letter letter) const noexcept {
        if (!IsValid()) {
            return MCC::Accidental::Invalid();
        }
        const int32_t order = SharpOrder(letter);
        if (order < Sharps()) {
            return MCC::Accidental::Sharp();
        }
        if (6 - order < Flats()) {
            return MCC::Accidental::Flat();
        }
        return MCC::Accidental::Natural();
    }

    friend constexpr bool operator==(KeySignature a, KeySignature b) noexcept {
        return a._fifths == b._fifths;
    }

    friend constexpr bool operator!=(KeySignature a, KeySignature b) noexcept {
        return !(a == b);
    }
};
 
} // namespace MCC
 
#endif // MCC_KEY_KEY_SIGNATURE_H