Chord.h

#ifndef MCC_CHORD_CHORD_H
#define MCC_CHORD_CHORD_H
 
#include <MCC_BuildSettings.h>
 
#include <stddef.h>
#include <stdint.h>
 
#include <MCC/Chord/ChordPattern.h>
#include <MCC/Interval/Transposition.h>
#include <MCC/Pitch/NoteName.h>
#include <MCC/Pitch/Pitch.h>
#include <MCC/Pitch/PitchClass.h>
 
namespace MCC {

class Chord {
    NoteName _root;
    ChordPattern _pattern;
 
public:
    constexpr Chord() noexcept : _root(), _pattern() {}

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

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

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

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

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

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

    MCC_CONSTEXPR14 NoteName ToneAt(int32_t tone) const noexcept {
        return _root + _pattern.ToneInterval(tone);
    }

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

    MCC_CONSTEXPR14 bool Contains(NoteName noteName) const noexcept {
        if (!noteName.IsValid()) {
            return false;
        }
        const uint8_t count = ToneCount();
        for (uint8_t tone = 1; tone <= count; ++tone) {
            if (ToneAt(tone) == noteName) {
                return true;
            }
        }
        return false;
    }

    MCC_CONSTEXPR14 bool ContainsPitchClass(MCC::PitchClass pitchClass) const noexcept {
        if (!IsValid() || !pitchClass.IsValid()) {
            return false;
        }
        const int32_t offset =
            ((static_cast<int32_t>(pitchClass.Value()) - _root.PitchClass().Value()) % 12 + 12) % 12;
        return ((static_cast<uint32_t>(_pattern.PitchClassMask()) >> offset) & 1u) != 0;
    }

    size_t Voicing(int32_t inversion, int32_t rootOctave,
                   MCC::Pitch* pitches, size_t capacity) const noexcept {
        const uint8_t count = ToneCount();
        if (count == 0 || inversion < 0 || inversion >= count) {
            return 0;
        }
        MCC::Pitch previous;
        for (uint8_t i = 0; i < count; ++i) {
            const int32_t tone = (inversion + i) % count + 1;
            MCC::Pitch pitch = PitchAt(tone, rootOctave);
            while (previous.IsValid() && pitch.IsValid() && !IsLowerThan(previous, pitch)) {
                pitch = pitch.MovedByOctaves(1);
            }
            if (i < capacity) {
                pitches[i] = pitch;
            }
            previous = pitch;
        }
        return count;
    }

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

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