ScalePattern.h

#ifndef MCC_SCALE_SCALE_PATTERN_H
#define MCC_SCALE_SCALE_PATTERN_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
#include <MCC/Interval/Interval.h>
 
namespace MCC {

namespace Detail {
struct ScalePatternStorage;
}

class ScalePattern {
public:
    static constexpr uint8_t MaximumDegrees = 12;
 
private:
    friend struct Detail::ScalePatternStorage;
 
    uint16_t _semitones;   // bit k set: a degree lies k semitones above the root
    uint8_t _steps[6];     // diatonic steps of degree i in nibble i
 
    constexpr ScalePattern(uint16_t semitones, uint8_t steps0,
                           uint8_t steps1, uint8_t steps2,
                           uint8_t steps3, uint8_t steps4,
                           uint8_t steps5) noexcept
        : _semitones(semitones),
          _steps{steps0, steps1, steps2, steps3, steps4, steps5} {}
 
    // Semitones of the major-scale degree `steps` above the root: 0 2 4 5 7 9 11.
    // Computed rather than tabled so AVR keeps no lookup table in RAM.
    static constexpr int32_t NaturalSemitones(int32_t steps) noexcept {
        return steps * 2 - (steps >= 3 ? 1 : 0);
    }
 
    constexpr uint8_t StepsAt(uint8_t index) const noexcept {
        return static_cast<uint8_t>((_steps[index / 2] >> ((index % 2) * 4)) & 0x0F);
    }
 
    MCC_CONSTEXPR14 int32_t SemitonesAt(uint8_t index) const noexcept {
        uint8_t seen = 0;
        for (int32_t k = 0; k < 12; ++k) {
            if ((static_cast<uint32_t>(_semitones) >> k) & 1u) {
                if (seen == index) {
                    return k;
                }
                ++seen;
            }
        }
        return -1;
    }
 
public:
    constexpr ScalePattern() noexcept : _semitones(0), _steps{0, 0, 0, 0, 0, 0} {}

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

    static MCC_CONSTEXPR14 ScalePattern FromFormula(const char* formula) noexcept {
        ScalePattern pattern;
        if (formula == nullptr) {
            return Invalid();
        }
        uint8_t count = 0;
        int32_t previous = -1;
        // Index-based scanning without `continue`: GCC 7 (the Arduino AVR
        // toolchain) miscounts constexpr loops that `continue` past an
        // advancing pointer.
        int32_t i = 0;
        while (formula[i] != '\0') {
            if (formula[i] == ' ') {
                ++i;
            } else {
                int32_t accidental = 0;
                while (formula[i] == 'b' || formula[i] == '#') {
                    accidental += (formula[i] == '#') ? 1 : -1;
                    ++i;
                }
                if (formula[i] < '1' || formula[i] > '7') {
                    return Invalid();
                }
                const int32_t steps = formula[i] - '1';
                ++i;
                if (formula[i] != ' ' && formula[i] != '\0') {
                    return Invalid();
                }
                const int32_t semitones = NaturalSemitones(steps) + accidental;
                if (count == MaximumDegrees || semitones <= previous || semitones > 11 ||
                    (count == 0 && (steps != 0 || semitones != 0)) ||
                    !Interval::FromSteps(steps, semitones).IsValid()) {
                    return Invalid();
                }
                pattern._semitones = static_cast<uint16_t>(pattern._semitones | (1u << semitones));
                pattern._steps[count / 2] = static_cast<uint8_t>(
                    pattern._steps[count / 2] | (steps << ((count % 2) * 4)));
                previous = semitones;
                ++count;
            }
        }
        return count == 0 ? Invalid() : pattern;
    }

    constexpr bool IsValid() const noexcept { return _semitones != 0; }

    MCC_CONSTEXPR14 uint8_t DegreeCount() const noexcept {
        uint8_t count = 0;
        for (int32_t k = 0; k < 12; ++k) {
            count = static_cast<uint8_t>(count + ((static_cast<uint32_t>(_semitones) >> k) & 1u));
        }
        return count;
    }

    MCC_CONSTEXPR14 Interval DegreeInterval(int32_t degree) const noexcept {
        if (degree < 1 || degree > DegreeCount()) {
            return Interval::Invalid();
        }
        const uint8_t index = static_cast<uint8_t>(degree - 1);
        return Interval::FromSteps(StepsAt(index), SemitonesAt(index));
    }

    MCC_CONSTEXPR14 bool ContainsSemitone(int32_t semitones) const noexcept {
        const int32_t reduced = ((semitones % 12) + 12) % 12;
        return IsValid() && ((static_cast<uint32_t>(_semitones) >> reduced) & 1u) != 0;
    }

    friend MCC_CONSTEXPR14 bool operator==(const ScalePattern& a, const ScalePattern& b) noexcept {
        if (a._semitones != b._semitones) {
            return false;
        }
        for (uint8_t i = 0; i < 6; ++i) {
            if (a._steps[i] != b._steps[i]) {
                return false;
            }
        }
        return true;
    }

    friend MCC_CONSTEXPR14 bool operator!=(const ScalePattern& a, const ScalePattern& b) noexcept {
        return !(a == b);
    }
};

namespace Detail {
 
struct ScalePatternStorage {
    static constexpr ScalePattern Make(uint16_t semitones, uint8_t steps0,
                                       uint8_t steps1, uint8_t steps2,
                                       uint8_t steps3, uint8_t steps4,
                                       uint8_t steps5) noexcept {
        return ScalePattern(semitones, steps0, steps1, steps2,
                            steps3, steps4, steps5);
    }
};
 
} // namespace Detail
 
} // namespace MCC
 
#endif // MCC_SCALE_SCALE_PATTERN_H