Scale.h

#ifndef MCC_SCALE_SCALE_H
#define MCC_SCALE_SCALE_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
#include <MCC/Interval/Transposition.h>
#include <MCC/Pitch/NoteName.h>
#include <MCC/Pitch/Pitch.h>
#include <MCC/Pitch/PitchClass.h>
#include <MCC/Scale/ScalePattern.h>
 
namespace MCC {

class Scale {
    NoteName _root;
    ScalePattern _pattern;
 
public:
    constexpr Scale() noexcept : _root(), _pattern() {}

    constexpr Scale(NoteName root, ScalePattern pattern) noexcept
        : _root(root.IsValid() && pattern.IsValid() ? root : NoteName::Invalid()),
          _pattern(root.IsValid() && pattern.IsValid() ? pattern : ScalePattern::Invalid()) {}

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

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

    constexpr NoteName Root() const noexcept { return _root; }

    constexpr ScalePattern Pattern() const noexcept { return _pattern; }

    MCC_CONSTEXPR14 uint8_t DegreeCount() const noexcept { return _pattern.DegreeCount(); }

    MCC_CONSTEXPR14 NoteName NoteAt(int32_t degree) const noexcept {
        return _root + _pattern.DegreeInterval(degree);
    }

    MCC_CONSTEXPR14 MCC::Pitch PitchAt(int32_t degree, int32_t rootOctave) const noexcept {
        return MCC::Pitch(_root, rootOctave) + _pattern.DegreeInterval(degree);
    }

    MCC_CONSTEXPR14 uint8_t DegreeOf(NoteName noteName) const noexcept {
        if (!noteName.IsValid()) {
            return 0;
        }
        const uint8_t count = DegreeCount();
        for (uint8_t degree = 1; degree <= count; ++degree) {
            if (NoteAt(degree) == noteName) {
                return degree;
            }
        }
        return 0;
    }

    MCC_CONSTEXPR14 bool Contains(NoteName noteName) const noexcept {
        return DegreeOf(noteName) != 0;
    }

    constexpr bool ContainsPitchClass(MCC::PitchClass pitchClass) const noexcept {
        return IsValid() && pitchClass.IsValid() &&
            _pattern.ContainsSemitone(
                static_cast<int32_t>(pitchClass.Value()) - _root.PitchClass().Value());
    }

    friend constexpr bool operator==(const Scale& a, const Scale& b) noexcept {
        return a._root == b._root && a._pattern == b._pattern;
    }

    friend constexpr bool operator!=(const Scale& a, const Scale& b) noexcept {
        return !(a == b);
    }
};
 
} // namespace MCC
 
#endif // MCC_SCALE_SCALE_H