ChordPattern.h

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

namespace Detail {
struct ChordPatternStorage;
}

class ChordPattern {
public:
    static constexpr uint8_t MaximumTones = 7;
 
private:
    friend struct Detail::ChordPatternStorage;
 
    uint32_t _semitones;   // bit k set: a tone lies k semitones above the root
    uint8_t _steps[4];     // diatonic steps of tone i in nibble i
 
    constexpr ChordPattern(uint32_t semitones, uint8_t steps0,
                           uint8_t steps1, uint8_t steps2,
                           uint8_t steps3) noexcept
        : _semitones(semitones), _steps{steps0, steps1, steps2, steps3} {}
 
    // Semitones of the major-scale degree `steps` above the root, extended
    // past the octave. Computed rather than tabled so AVR keeps no RAM table.
    static constexpr int32_t NaturalSemitones(int32_t steps) noexcept {
        return (steps / 7) * 12 + (steps % 7) * 2 - ((steps % 7) >= 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 < 24; ++k) {
            if ((_semitones >> k) & 1u) {
                if (seen == index) {
                    return k;
                }
                ++seen;
            }
        }
        return -1;
    }
 
public:
    constexpr ChordPattern() noexcept : _semitones(0), _steps{0, 0, 0, 0} {}

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

    static MCC_CONSTEXPR14 ChordPattern FromFormula(const char* formula) noexcept {
        ChordPattern pattern;
        if (formula == nullptr) {
            return Invalid();
        }
        uint8_t count = 0;
        int32_t previous = -1;
        // Index-based scanning without `continue` keeps GCC 7 (the Arduino
        // AVR toolchain) able to evaluate the loop at compile time.
        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;
                }
                int32_t number = 0;
                while (formula[i] >= '0' && formula[i] <= '9' && number < 100) {
                    number = number * 10 + (formula[i] - '0');
                    ++i;
                }
                if (number < 1 || number > 13 ||
                    (formula[i] != ' ' && formula[i] != '\0')) {
                    return Invalid();
                }
                const int32_t steps = number - 1;
                const int32_t semitones = NaturalSemitones(steps) + accidental;
                if (count == MaximumTones || semitones <= previous || semitones > 23 ||
                    (count == 0 && (steps != 0 || semitones != 0)) ||
                    !Interval::FromSteps(steps, semitones).IsValid()) {
                    return Invalid();
                }
                pattern._semitones |= (static_cast<uint32_t>(1) << 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 ToneCount() const noexcept {
        uint8_t count = 0;
        for (int32_t k = 0; k < 24; ++k) {
            count = static_cast<uint8_t>(count + ((_semitones >> k) & 1u));
        }
        return count;
    }

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

    constexpr uint16_t PitchClassMask() const noexcept {
        return static_cast<uint16_t>((_semitones | (_semitones >> 12)) & 0x0FFFu);
    }

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

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

namespace Detail {
 
struct ChordPatternStorage {
    static constexpr ChordPattern Make(uint32_t semitones, uint8_t steps0,
                                       uint8_t steps1, uint8_t steps2,
                                       uint8_t steps3) noexcept {
        return ChordPattern(semitones, steps0, steps1, steps2, steps3);
    }
};
 
} // namespace Detail
 
} // namespace MCC
 
#endif // MCC_CHORD_CHORD_PATTERN_H