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 MIDIChannelCN {
    friend class MIDIAddress;
 
  public:
    constexpr MIDIChannelCN() : addresses{0, 0, 0, 0} {}
    constexpr MIDIChannelCN(Channel channel, Cable cableNumber = CABLE_1)
        : addresses{
              1,
              0,
              channel.getRaw(),
              cableNumber.getRaw(),
          } {}
 
    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;
    }
 
    constexpr bool isValid() const { return addresses.valid; }
 
    constexpr explicit operator bool() const { return isValid(); }
 
    constexpr static MIDIChannelCN invalid() { return {}; }
 
  private:
    RawMIDIAddress addresses;
};
 
using MIDICNChannel [[deprecated("Use MIDIChannelCN instead")]] = MIDIChannelCN;
 
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, MIDIChannelCN 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(const MIDIChannelCN &address)
        : addresses(address.addresses) {}
 
    constexpr static MIDIAddress invalid() { return {}; }
 
 
  public:
 
    MIDIAddress &operator+=(const RelativeMIDIAddress &rhs);
 
    MIDIAddress &operator-=(const RelativeMIDIAddress &rhs);
 
    MIDIAddress operator+(const RelativeMIDIAddress &rhs) const;
 
    MIDIAddress operator-(const 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==(const 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!=(const 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(const MIDIAddress &toMatch,
                            const MIDIAddress &base);
 
    static bool matchAddressInRange(const MIDIAddress &toMatch,
                                    const MIDIAddress &base, uint8_t length);
 
 
  private:
    RawMIDIAddress addresses;
};
 
using MIDICNChannelAddress [[deprecated("Use MIDIAddress instead")]] =
    MIDIAddress;
 
END_CS_NAMESPACE