MIDIInputElement.hpp

Go to the documentation of this file.

#pragma once
 
#include <Def/MIDIAddress.hpp>
#include <MIDI_Parsers/MIDI_MessageTypes.hpp>
 
#include <Banks/Bank.hpp> // Bank<N>, BankSettingChangeCallback
 
#include <AH/Containers/Updatable.hpp>
#include <AH/STL/type_traits>
 
BEGIN_CS_NAMESPACE
 
// -------------------------------------------------------------------------- //
 
template <MIDIMessageType Type>
class MIDIInputElement : public AH::UpdatableCRTP<MIDIInputElement<Type>> {
  protected:
    MIDIInputElement() = default;
 
  public:
    virtual ~MIDIInputElement() = default;
 
  public:
    using MessageType =
        typename std::conditional<Type == MIDIMessageType::SysExStart,
                                  SysExMessage, ChannelMessage>::type;
 
    virtual void begin() {} // LCOV_EXCL_LINE
 
    virtual void reset() {} // LCOV_EXCL_LINE
 
    virtual void update() {} // LCOV_EXCL_LINE
 
    virtual bool updateWith(MessageType midimsg) = 0;
 
    static bool updateAllWith(MessageType midimsg) {
        for (auto &el : MIDIInputElement::updatables) {
            if (el.updateWith(midimsg)) {
                el.moveDown();
                return true;
            }
        }
        return false;
    }
 
    static void updateAll() {
        MIDIInputElement::applyToAll(&MIDIInputElement::update);
    }
 
    static void beginAll() {
        MIDIInputElement::applyToAll(&MIDIInputElement::begin);
    }
 
    static void resetAll() {
        MIDIInputElement::applyToAll(&MIDIInputElement::reset);
    }
};
 
// -------------------------------------------------------------------------- //
 
template <MIDIMessageType Type, class Matcher>
class MatchingMIDIInputElement : public MIDIInputElement<Type> {
  protected:
    MatchingMIDIInputElement(const Matcher &matcher) : matcher(matcher) {}
 
  public:
    using MessageType = typename MIDIInputElement<Type>::MessageType;
 
    bool updateWith(MessageType midimsg) override {
        auto match = matcher(midimsg);
        if (match.match)
            handleUpdate(match);
        return match.match;
    }
 
    virtual void handleUpdate(typename Matcher::Result match) = 0;
 
  protected:
    Matcher matcher;
};
 
// -------------------------------------------------------------------------- //
 
template <MIDIMessageType Type, class Matcher>
class BankableMatchingMIDIInputElement
    : public MatchingMIDIInputElement<Type, Matcher>,
      public BankSettingChangeCallback {
    friend class Bank<Matcher::getBankSize()>;
 
  protected:
    BankableMatchingMIDIInputElement(const Matcher &matcher)
        : MatchingMIDIInputElement<Type, Matcher>(matcher) {
        this->matcher.getBank().add(this);
    }
 
    uint8_t getActiveBank() const { return this->matcher.getSelection(); }
 
  public:
    virtual ~BankableMatchingMIDIInputElement() {
        this->matcher.getBank().remove(this);
    }
};
 
// -------------------------------------------------------------------------- //
 
using MIDIInputElementNote = MIDIInputElement<MIDIMessageType::NoteOn>;
using MIDIInputElementKP = MIDIInputElement<MIDIMessageType::KeyPressure>;
using MIDIInputElementCC = MIDIInputElement<MIDIMessageType::ControlChange>;
using MIDIInputElementPC = MIDIInputElement<MIDIMessageType::ProgramChange>;
using MIDIInputElementCP = MIDIInputElement<MIDIMessageType::ChannelPressure>;
using MIDIInputElementPB = MIDIInputElement<MIDIMessageType::PitchBend>;
using MIDIInputElementSysEx = MIDIInputElement<MIDIMessageType::SysExStart>;
 
END_CS_NAMESPACE