MIDI_Pipes.hpp

Go to the documentation of this file.

#pragma once
 
#include <Settings/SettingsWrapper.hpp>
#if !DISABLE_PIPES
 
#include <AH/Containers/BitArray.hpp>
#include <AH/STL/cstdint>
#include <AH/STL/limits>
#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
 
struct MIDIStaller;
MIDIStaller *const eternal_stall =
    reinterpret_cast<MIDIStaller *>(std::numeric_limits<std::uintptr_t>::max());
 
class MIDI_Pipe;
class MIDI_Source;
class MIDI_Sink;
using TrueMIDI_Sink = MIDI_Sink;
using TrueMIDI_Source = MIDI_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(SysCommonMessage) = 0;
    virtual void sinkMIDIfromPipe(RealTimeMessage) = 0;
 
 
 
    void connectSourcePipe(MIDI_Pipe *source);
    void disconnectSourcePipes();
    bool disconnect(TrueMIDI_Source &source);
    bool disconnect(MIDI_Pipe &) = delete;
    bool hasSourcePipe() const { return sourcePipe != nullptr; }
    MIDI_Pipe *getSourcePipe() { return sourcePipe; }
 
 
  private:
    virtual void stallDownstream(MIDIStaller *, MIDI_Source *) {}
    virtual void unstallDownstream(MIDIStaller *, MIDI_Source *) {}
    virtual MIDI_Sink *getFinalSink() { return this; }
    void disconnectSourcePipesShallow();
 
  protected:
    MIDI_Pipe *sourcePipe = nullptr;
 
    friend class MIDI_Pipe;
 
  public:
    static void swap(MIDI_Sink &a, MIDI_Sink &b);
    friend void swap(MIDI_Sink &a, MIDI_Sink &b) { swap(a, b); }
};
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
class MIDI_Source {
  public:
    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 sourceMIDItoPipe(ChannelMessage);
    void sourceMIDItoPipe(SysExMessage);
    void sourceMIDItoPipe(SysCommonMessage);
    void sourceMIDItoPipe(RealTimeMessage);
 
 
 
    void stall(MIDIStaller *cause = eternal_stall);
    void unstall(MIDIStaller *cause = eternal_stall);
    bool isStalled() const;
    MIDIStaller *getStaller() const;
    const char *getStallerName() const;
    void handleStallers() const;
 
 
 
    void connectSinkPipe(MIDI_Pipe *sink);
    void disconnectSinkPipes();
    bool disconnect(TrueMIDI_Sink &sink);
    bool disconnect(MIDI_Pipe &) = delete;
    bool hasSinkPipe() const { return sinkPipe != nullptr; }
    MIDI_Pipe *getSinkPipe() { return sinkPipe; }
 
 
  private:
    virtual void stallUpstream(MIDIStaller *, MIDI_Sink *) {}
    virtual void unstallUpstream(MIDIStaller *, MIDI_Sink *) {}
    virtual MIDI_Source *getInitialSource() { return this; }
    void disconnectSinkPipesShallow();
 
  protected:
    MIDI_Pipe *sinkPipe = nullptr;
 
    friend class MIDI_Pipe;
 
  public:
    static void swap(MIDI_Source &a, MIDI_Source &b);
    friend void swap(MIDI_Source &a, MIDI_Source &b) { swap(a, b); }
};
 
// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
 
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:
 
    virtual void mapForwardMIDI(ChannelMessage msg) { sourceMIDItoSink(msg); }
    virtual void mapForwardMIDI(SysExMessage msg) { sourceMIDItoSink(msg); }
    virtual void mapForwardMIDI(SysCommonMessage msg) { sourceMIDItoSink(msg); }
    virtual void mapForwardMIDI(RealTimeMessage msg) { sourceMIDItoSink(msg); }
 
 
  public:
 
    bool isStalled() const { return sink_staller || through_staller; }
    MIDIStaller *getSinkStaller() const { return sink_staller; }
    const char *getSinkStallerName() const;
    MIDIStaller *getThroughStaller() const { return through_staller; }
    const char *getThroughStallerName() const;
    MIDIStaller *getStaller() const;
    const char *getStallerName() const;
    bool sinkIsUnstalledOrStalledBy(MIDIStaller *cause) {
        return sink_staller == nullptr || sink_staller == cause;
    }
    bool throughIsUnstalledOrStalledBy(MIDIStaller *cause) {
        return through_staller == nullptr || through_staller == cause;
    }
 
    void handleStallers() const;
 
 
  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; }
 
 
  public:
 
    void disconnect();
    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;
    }
    bool disconnect(MIDI_Pipe &) = delete;
 
    MIDI_Source *getSource() { return source; }
    MIDI_Sink *getSink() { return sink; }
    MIDI_Pipe *getThroughOut() { return throughOut; }
    MIDI_Pipe *getThroughIn() { return throughIn; }
 
    MIDI_Sink *getFinalSink() override {
        return hasSink() ? sink->getFinalSink() : nullptr;
    }
    MIDI_Source *getInitialSource() override {
        return hasSource() ? source->getInitialSource() : nullptr;
    }
 
 
  private:
 
    void connectSink(MIDI_Sink *sink);
    void disconnectSink();
    void connectSource(MIDI_Source *source);
    void disconnectSource();
 
 
  protected:
    template <class Message>
    void sourceMIDItoSink(Message msg) {
        if (hasSink())
            sink->sinkMIDIfromPipe(msg);
    }
 
  protected:
    template <class Message>
    void acceptMIDIfromSource(Message msg) {
        if (hasThroughOut())
            throughOut->acceptMIDIfromSource(msg);
        mapForwardMIDI(msg);
    }
 
  private:
    void sinkMIDIfromPipe(ChannelMessage msg) override {
        sourceMIDItoSink(msg);
    }
    void sinkMIDIfromPipe(SysExMessage msg) override { sourceMIDItoSink(msg); }
    void sinkMIDIfromPipe(SysCommonMessage msg) override {
        sourceMIDItoSink(msg);
    }
    void sinkMIDIfromPipe(RealTimeMessage msg) override {
        sourceMIDItoSink(msg);
    }
 
  private:
 
    void stallDownstream(MIDIStaller *cause, MIDI_Source *stallsrc) override;
    void unstallDownstream(MIDIStaller *cause, MIDI_Source *stallsrc) override;
 
    void stallUpstream(MIDIStaller *cause, MIDI_Sink *stallsrc) override;
    void unstallUpstream(MIDIStaller *cause, MIDI_Sink *stallsrc) override;
 
 
  private:
    MIDI_Sink *sink = nullptr;
    MIDI_Source *source = nullptr;
    MIDI_Pipe *&throughOut = MIDI_Source::sinkPipe;
    MIDI_Pipe *&throughIn = MIDI_Sink::sourcePipe;
    MIDIStaller *sink_staller = nullptr;
    MIDIStaller *through_staller = nullptr;
 
    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;
}
 
MIDI_Pipe &operator<<(MIDI_Pipe &, MIDI_Pipe &) = delete;
 
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>
MIDI_Pipe &operator>>(MIDI_Pipe &, MIDI_PipeFactory<N, Pipe> &) = delete;
 
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>
MIDI_Pipe &operator>>(MIDI_PipeFactory<N, Pipe> &, MIDI_Pipe &) = delete;
 
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()
 
#else
 
BEGIN_CS_NAMESPACE
 
struct TrueMIDI_Source {
    template <class... Args>
    void sourceMIDItoPipe(Args &&...) {}
};
struct TrueMIDI_Sink {};
struct TrueMIDI_SinkSource : TrueMIDI_Source, TrueMIDI_Sink {};
 
END_CS_NAMESPACE
 
#endif