MIDI_Pipes.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Containers/BitArray.hpp>
#include <AH/STL/utility>
#include <AH/Settings/Warnings.hpp>
#include <MIDI_Parsers/MIDI_MessageTypes.hpp>
#include <Settings/NamespaceSettings.hpp>
 
AH_DIAGNOSTIC_WERROR()
 
BEGIN_CS_NAMESPACE
 
using cn_t = uint8_t;
 
class MIDI_Pipe;
struct TrueMIDI_Sink;
struct TrueMIDI_Source;
 
class MIDI_Sink {
  public:
    MIDI_Sink() = default;
 
    MIDI_Sink(const MIDI_Sink &) = delete;
    MIDI_Sink &operator=(const MIDI_Sink &) = delete;
 
    MIDI_Sink(MIDI_Sink &&other);
    MIDI_Sink &operator=(MIDI_Sink &&other);
 
    virtual ~MIDI_Sink();
 
 
    virtual void sinkMIDIfromPipe(ChannelMessage) = 0;
    virtual void sinkMIDIfromPipe(SysExMessage) = 0;
    virtual void sinkMIDIfromPipe(RealTimeMessage) = 0;
 
 
 
    void connectSourcePipe(MIDI_Pipe *source);
    void disconnectSourcePipes();
    bool disconnect(TrueMIDI_Source &source);
    bool hasSourcePipe() const { return sourcePipe != nullptr; }
 
#ifndef ARDUINO
    MIDI_Pipe *getSourcePipe() { return sourcePipe; }
#endif
 
 
  private:
    virtual void lockDownstream(cn_t cn, bool lock) { (void)cn, (void)lock; }
    virtual MIDI_Sink *getFinalSink() { return this; }
    void disconnectSourcePipesShallow();
 
  protected:
    MIDI_Pipe *sourcePipe = nullptr;
 
    friend class MIDI_Pipe;
};
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
class MIDI_Source {
  public:
 
    void sourceMIDItoPipe(ChannelMessage);
    void sourceMIDItoPipe(SysExMessage);
    void sourceMIDItoPipe(RealTimeMessage);
 
    void exclusive(cn_t cn, bool exclusive = true);
    bool canWrite(cn_t cn) const;
 
 
    MIDI_Source() = default;
 
    MIDI_Source(const MIDI_Source &) = delete;
    MIDI_Source &operator=(const MIDI_Source &) = delete;
 
    MIDI_Source(MIDI_Source &&other);
    MIDI_Source &operator=(MIDI_Source &&other);
 
    virtual ~MIDI_Source();
 
 
    void connectSinkPipe(MIDI_Pipe *sink);
    void disconnectSinkPipes();
    bool disconnect(TrueMIDI_Sink &sink);
    bool hasSinkPipe() const { return sinkPipe != nullptr; }
 
#ifndef ARDUINO
    MIDI_Pipe *getSinkPipe() { return sinkPipe; }
#endif
 
 
  private:
    virtual MIDI_Source *getInitialSource() { return this; }
    void disconnectSinkPipesShallow();
 
  protected:
    MIDI_Pipe *sinkPipe = nullptr;
 
    friend class MIDI_Pipe;
};
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
struct TrueMIDI_Sink : MIDI_Sink {};
struct TrueMIDI_Source : MIDI_Source {};
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
class MIDI_Pipe : private MIDI_Sink, private MIDI_Source {
  public:
    MIDI_Pipe() = default;
 
    MIDI_Pipe(const MIDI_Pipe &) = delete;
    MIDI_Pipe &operator=(const MIDI_Pipe &) = delete;
 
    MIDI_Pipe(MIDI_Pipe &&) = delete;
    MIDI_Pipe &operator=(MIDI_Pipe &&) = delete;
 
    virtual ~MIDI_Pipe();
 
  private:
    void connectSink(MIDI_Sink *sink);
    void disconnectSink();
    void connectSource(MIDI_Source *source);
    void disconnectSource();
 
  public:
    bool hasSink() const { return sink != nullptr; }
    bool hasSource() const { return source != nullptr; }
    bool hasThroughOut() const { return throughOut != nullptr; }
    bool hasThroughIn() const { return throughIn != nullptr; }
 
  protected:
    void pipeMIDI(ChannelMessage msg) {
        // Forward 
        if (hasThroughOut())
            throughOut->pipeMIDI(msg);
        mapForwardMIDI(msg);
    }
    void pipeMIDI(SysExMessage msg) {
        if (hasThroughOut())
            throughOut->pipeMIDI(msg);
        mapForwardMIDI(msg);
    }
    void pipeMIDI(RealTimeMessage msg) {
        if (hasThroughOut())
            throughOut->pipeMIDI(msg);
        mapForwardMIDI(msg);
    }
 
  protected:
    void sourceMIDItoSink(ChannelMessage msg) {
        if (hasSink())
            sink->sinkMIDIfromPipe(msg);
    }
 
    void sourceMIDItoSink(SysExMessage msg) {
        if (hasSink())
            sink->sinkMIDIfromPipe(msg);
    }
 
    void sourceMIDItoSink(RealTimeMessage msg) {
        if (hasSink())
            sink->sinkMIDIfromPipe(msg);
    }
 
  private:
    virtual void mapForwardMIDI(ChannelMessage msg) { 
        // Optionally edit the message before passing it on
        sourceMIDItoSink(msg); 
    }
 
    virtual void mapForwardMIDI(SysExMessage msg) { 
        // Optionally edit the message before passing it on
        sourceMIDItoSink(msg); 
    }
 
    virtual void mapForwardMIDI(RealTimeMessage msg) { 
        // Optionally edit the message before passing it on
        sourceMIDItoSink(msg); 
    }
 
  private:
    void sinkMIDIfromPipe(ChannelMessage msg) override {
        // Called when data from Through In arrives, forward it to the sink
        sourceMIDItoSink(msg);
    }
    void sinkMIDIfromPipe(SysExMessage msg) override {
        // Called when data from Through In arrives, forward it to the sink
        sourceMIDItoSink(msg);
    }
    void sinkMIDIfromPipe(RealTimeMessage msg) override {
        // Called when data from Through In arrives, forward it to the sink
        sourceMIDItoSink(msg);
    }
 
  private:
    void lockDownstream(cn_t cn, bool lock) override {
        lockSelf(cn, lock);
        if (hasSink())
            sink->lockDownstream(cn, lock);
    }
 
    void lockUpstream(cn_t cn, bool lock) {
        lockSelf(cn, lock);
        if (hasThroughIn())
            throughIn->lockUpstream(cn, lock);
    }
 
    void lockSelf(cn_t cn, bool lock) { locks.set(cn, lock); }
 
  public:
    void disconnect();
 
    MIDI_Sink *getFinalSink() override {
        return hasSink() ? sink->getFinalSink() : nullptr;
    }
    MIDI_Source *getInitialSource() override {
        return hasSource() ? source->getInitialSource() : nullptr;
    }
 
    bool disconnect(TrueMIDI_Sink &sink) {
        if (getFinalSink() == &sink) {
            disconnect();
            return true;
        }
        if (hasThroughOut()) {
            return throughOut->disconnect(sink);
        }
        return false;
    }
 
    bool disconnect(TrueMIDI_Source &source) {
        if (getInitialSource() == &source) {
            disconnect();
            return true;
        }
        if (hasThroughIn()) {
            return throughIn->disconnect(source);
        }
        return false;
    }
 
#ifdef ARDUINO
  protected:
#endif
    MIDI_Pipe *getThroughOut() { return throughOut; }
    MIDI_Pipe *getThroughIn() { return throughIn; }
    MIDI_Source *getSource() { return source; }
    MIDI_Sink *getSink() { return sink; }
 
  public:
    void exclusive(cn_t cn, bool exclusive = true);
 
    bool isLocked(cn_t cn) const { return locks.get(cn); }
 
    bool isAvailableForWrite(cn_t cn) const {
        return !isLocked(cn) &&
               (!hasThroughOut() || throughOut->isAvailableForWrite(cn));
    }
 
  private:
    MIDI_Sink *sink = nullptr;
    MIDI_Source *source = nullptr;
    MIDI_Pipe *&throughOut = MIDI_Source::sinkPipe;
    MIDI_Pipe *&throughIn = MIDI_Sink::sourcePipe;
    AH::BitArray<16> locks;
 
    friend class MIDI_Sink;
    friend class MIDI_Source;
};
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
struct TrueMIDI_SinkSource : TrueMIDI_Sink, TrueMIDI_Source {};
 
using BidirectionalMIDI_Pipe = std::pair<MIDI_Pipe, MIDI_Pipe>;
 
inline MIDI_Pipe &operator>>(TrueMIDI_Source &source, MIDI_Pipe &pipe) {
    source.connectSinkPipe(&pipe);
    return pipe;
}
 
inline TrueMIDI_Sink &operator>>(MIDI_Pipe &pipe, TrueMIDI_Sink &sink) {
    sink.connectSourcePipe(&pipe);
    return sink;
}
 
inline MIDI_Pipe &operator<<(TrueMIDI_Sink &sink, MIDI_Pipe &pipe) {
    sink.connectSourcePipe(&pipe);
    return pipe;
}
 
inline TrueMIDI_Source &operator<<(MIDI_Pipe &pipe, TrueMIDI_Source &source) {
    source.connectSinkPipe(&pipe);
    return source;
}
 
inline TrueMIDI_SinkSource &operator|(BidirectionalMIDI_Pipe &pipe,
                                      TrueMIDI_SinkSource &sinksource) {
    sinksource.connectSinkPipe(&pipe.first);
    sinksource.connectSourcePipe(&pipe.second);
    return sinksource;
}
 
inline BidirectionalMIDI_Pipe &operator|(TrueMIDI_SinkSource &sinksource,
                                         BidirectionalMIDI_Pipe &pipe) {
    sinksource.connectSinkPipe(&pipe.second);
    sinksource.connectSourcePipe(&pipe.first);
    return pipe;
}
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
template <size_t N, class Pipe = MIDI_Pipe>
struct MIDI_PipeFactory {
    Pipe pipes[N];
    size_t index = 0;
 
    Pipe &getNext() {
        if (index >= N)
            FATAL_ERROR(F("Not enough pipes available"), 0x2459);
        return pipes[index++];
    }
    Pipe &operator[](size_t i) { return pipes[i]; }
    const Pipe &operator[](size_t i) const { return pipes[i]; }
};
 
template <size_t N>
using BidirectionalMIDI_PipeFactory =
    MIDI_PipeFactory<N, BidirectionalMIDI_Pipe>;
 
template <size_t N, class Pipe>
inline MIDI_Pipe &operator>>(TrueMIDI_Source &source,
                             MIDI_PipeFactory<N, Pipe> &pipe_fact) {
    return source >> pipe_fact.getNext();
}
 
template <size_t N, class Pipe>
inline TrueMIDI_Sink &operator>>(MIDI_PipeFactory<N, Pipe> &pipe_fact,
                                 TrueMIDI_Sink &sink) {
    return pipe_fact.getNext() >> sink;
}
 
template <size_t N, class Pipe>
inline MIDI_Pipe &operator<<(TrueMIDI_Sink &sink,
                             MIDI_PipeFactory<N, Pipe> &pipe_fact) {
    return sink << pipe_fact.getNext();
}
 
template <size_t N, class Pipe>
inline TrueMIDI_Source &operator<<(MIDI_PipeFactory<N, Pipe> &pipe_fact,
                                   TrueMIDI_Source &source) {
    return pipe_fact.getNext() << source;
}
 
template <size_t N>
inline TrueMIDI_SinkSource &
operator|(BidirectionalMIDI_PipeFactory<N> &pipe_fact,
          TrueMIDI_SinkSource &sinksource) {
    return pipe_fact.getNext() | sinksource;
}
 
template <size_t N>
inline BidirectionalMIDI_Pipe &
operator|(TrueMIDI_SinkSource &sinksource,
          BidirectionalMIDI_PipeFactory<N> &pipe_fact) {
    return sinksource | pipe_fact.getNext();
}
 
 
END_CS_NAMESPACE
 
AH_DIAGNOSTIC_POP()