MIDIAddress.hpp

Go to the documentation of this file.

/* ✔ */
 
#pragma once
 
#include <Def/Def.hpp>
 
BEGIN_CS_NAMESPACE
 
struct __attribute__((packed)) RawMIDIAddress {
    bool valid : 1;
    uint8_t address : 7;
    uint8_t channel : 4;
    uint8_t cableNumber : 4;
};
 
class MIDIChannelCable {
    friend class MIDIAddress;
 
  public:
 
    constexpr MIDIChannelCable() : addresses{0, 0, 0, 0} {}
    constexpr MIDIChannelCable(Channel channel, Cable cableNumber = CABLE_1)
        : addresses{1, 0, channel.getRaw(), cableNumber.getRaw()} {}
 
    constexpr static MIDIChannelCable invalid() { return {}; }
 
 
  public:
 
    constexpr Channel getChannel() const { return Channel{addresses.channel}; }
    constexpr uint8_t getRawChannel() const { return addresses.channel; }
 
    constexpr Cable getCableNumber() const {
        return Cable(addresses.cableNumber);
    }
    constexpr uint8_t getRawCableNumber() const {
        return addresses.cableNumber;
    }
 
 
  public:
 
    constexpr bool operator==(MIDIChannelCable rhs) const {
        return this->addresses.valid && rhs.addresses.valid &&
               this->addresses.channel == rhs.addresses.channel &&
               this->addresses.cableNumber == rhs.addresses.cableNumber;
    }
 
    constexpr bool operator!=(MIDIChannelCable rhs) const {
        return this->addresses.valid && rhs.addresses.valid &&
               !(this->addresses.channel == rhs.addresses.channel &&
                 this->addresses.cableNumber == rhs.addresses.cableNumber);
    }
 
    constexpr bool isValid() const { return addresses.valid; }
 
    constexpr explicit operator bool() const { return isValid(); }
 
 
  public:
 
    static bool matchSingle(MIDIChannelCable toMatch, MIDIChannelCable base) {
        return base == toMatch;
    }
 
 
  private:
    RawMIDIAddress addresses;
};
 
class RelativeMIDIAddress {
    friend class MIDIAddress;
 
  public:
    constexpr RelativeMIDIAddress() : addresses{0, 0, 0, 0} {}
    constexpr RelativeMIDIAddress(int deltaAddress, int deltaChannel = 0,
                                  int deltaCableNumber = 0)
        : addresses{
              1,
              (uint8_t)deltaAddress,
              (uint8_t)deltaChannel,
              (uint8_t)deltaCableNumber,
          } {}
    constexpr bool isValid() const { return addresses.valid; }
 
    RelativeMIDIAddress &operator+=(RelativeMIDIAddress that);
 
  private:
    RawMIDIAddress addresses;
    static_assert(((-1) & 0x7F) == 0x7F,
                  "Negative numbers must be two's complement");
};
 
class MIDIAddress {
  public:
 
    constexpr MIDIAddress()
        : addresses{
              0,
              0,
              0,
              0,
          } {}
 
    constexpr MIDIAddress(int address, MIDIChannelCable channelCN)
        : addresses{
              1,
              (uint8_t)address,
              channelCN.getRawChannel(),
              channelCN.getRawCableNumber(),
          } {} // Deliberate overflow for negative numbers
 
    constexpr MIDIAddress(int address, Channel channel = CHANNEL_1,
                          Cable cableNumber = CABLE_1)
        : addresses{
              1,
              (uint8_t)address,
              channel.getRaw(),
              cableNumber.getRaw(),
          } {} // Deliberate overflow for negative numbers
 
    constexpr MIDIAddress(int address, Cable cableNumber)
        : addresses{
              1,
              (uint8_t)address,
              0,
              cableNumber.getRaw(),
          } {} // Deliberate overflow for negative numbers
 
    constexpr MIDIAddress(Channel channel, Cable cableNumber = CABLE_1)
        : addresses{
              1,
              0,
              channel.getRaw(),
              cableNumber.getRaw(),
          } {}
 
    constexpr MIDIAddress(MIDIChannelCable address)
        : addresses(address.addresses) {}
 
    constexpr static MIDIAddress invalid() { return {}; }
 
 
  public:
 
    MIDIAddress &operator+=(RelativeMIDIAddress rhs);
 
    MIDIAddress &operator-=(RelativeMIDIAddress rhs);
 
    MIDIAddress operator+(RelativeMIDIAddress rhs) const;
 
    MIDIAddress operator-(RelativeMIDIAddress rhs) const;
 
 
  public:
 
    constexpr uint8_t getAddress() const { return addresses.address; }
 
    constexpr Channel getChannel() const { return Channel{addresses.channel}; }
    constexpr uint8_t getRawChannel() const { return addresses.channel; }
 
    constexpr Cable getCableNumber() const {
        return Cable(addresses.cableNumber);
    }
    constexpr uint8_t getRawCableNumber() const {
        return addresses.cableNumber;
    }
 
 
  public:
 
    constexpr bool operator==(MIDIAddress rhs) const {
        return this->addresses.valid && rhs.addresses.valid &&
               this->addresses.address == rhs.addresses.address &&
               this->addresses.channel == rhs.addresses.channel &&
               this->addresses.cableNumber == rhs.addresses.cableNumber;
    }
 
    constexpr bool operator!=(MIDIAddress rhs) const {
        return this->addresses.valid && rhs.addresses.valid &&
               !(this->addresses.address == rhs.addresses.address &&
                 this->addresses.channel == rhs.addresses.channel &&
                 this->addresses.cableNumber == rhs.addresses.cableNumber);
    }
 
    constexpr bool isValid() const { return addresses.valid; }
 
    constexpr explicit operator bool() const { return isValid(); }
 
 
  public:
 
    static bool matchSingle(MIDIAddress toMatch, MIDIAddress base) {
        return base == toMatch;
    }
 
    static bool matchAddressInRange(MIDIAddress toMatch, MIDIAddress base,
                                    uint8_t length);
 
 
  private:
    RawMIDIAddress addresses;
};
 
END_CS_NAMESPACE