MIDICNChannelAddress.hpp

Go to the documentation of this file.

/* ✔ */
 
#pragma once
 
#include <Def/Def.hpp>
 
BEGIN_CS_NAMESPACE
 
struct __attribute__((packed)) RawMIDICNChannelAddress {
    bool valid : 1;
    uint8_t address : 7;
    uint8_t channel : 4;
    uint8_t cableNumber : 4;
};
 
class MIDICNChannel {
    friend class MIDICNChannelAddress;
 
  public:
    constexpr MIDICNChannel() : addresses{0, 0, 0, 0} {}
    constexpr MIDICNChannel(Channel channel, int cableNumber = 0)
        : addresses{
              1,
              0,
              (uint8_t)channel.getRaw(),
              (uint8_t)cableNumber,
          } {}
 
    constexpr Channel getChannel() const {
        return Channel{int8_t(addresses.channel)};
    }
 
    constexpr uint8_t getRawChannel() const { return addresses.channel; }
 
    constexpr uint8_t getCableNumber() const { return addresses.cableNumber; }
 
    constexpr bool isValid() const { return addresses.valid; }
 
    constexpr explicit operator bool() const { return isValid(); }
 
    constexpr static MIDICNChannel invalid() { return {}; }
 
  private:
    RawMIDICNChannelAddress addresses;
};
 
class RelativeMIDICNChannelAddress {
    friend class MIDICNChannelAddress;
 
  public:
    constexpr RelativeMIDICNChannelAddress() : addresses{0, 0, 0, 0} {}
    constexpr RelativeMIDICNChannelAddress(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; }
 
  private:
    RawMIDICNChannelAddress addresses;
    static_assert(((-1) & 0x7F) == 0x7F,
                  "Negative numbers must be two's complement");
};
 
class MIDICNChannelAddress {
  public:
    constexpr MIDICNChannelAddress()
        : addresses{
              0,
              0,
              0,
              0,
          } {}
    constexpr MIDICNChannelAddress(int address, MIDICNChannel channelCN)
        : addresses{
              1,
              (uint8_t)address,
              channelCN.getRawChannel(),
              channelCN.getCableNumber(),
          } {}
    constexpr MIDICNChannelAddress(int address, Channel channel = CHANNEL_1,
                                   int cableNumber = 0x0)
        : addresses{
              1,
              (uint8_t)address,
              (uint8_t)channel.getRaw(),
              (uint8_t)cableNumber,
          } {} // Deliberate overflow for negative numbers
    constexpr MIDICNChannelAddress(Channel channel, int cableNumber = 0x0)
        : addresses{
              1,
              0,
              (uint8_t)channel.getRaw(),
              (uint8_t)cableNumber,
          } {} // Deliberate overflow for negative numbers
    constexpr MIDICNChannelAddress(const MIDICNChannel &address)
        : addresses(address.addresses) {}
 
    MIDICNChannelAddress &operator+=(const RelativeMIDICNChannelAddress &rhs);
 
    MIDICNChannelAddress &operator-=(const RelativeMIDICNChannelAddress &rhs);
 
    MIDICNChannelAddress
    operator+(const RelativeMIDICNChannelAddress &rhs) const;
 
    MIDICNChannelAddress
    operator-(const RelativeMIDICNChannelAddress &rhs) const;
 
    constexpr bool operator==(const MIDICNChannelAddress &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 MIDICNChannelAddress &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 uint8_t getAddress() const { return addresses.address; }
 
    constexpr Channel getChannel() const {
        return Channel{int8_t(addresses.channel)};
    }
    constexpr uint8_t getRawChannel() const { return addresses.channel; }
 
    constexpr uint8_t getCableNumber() const { return addresses.cableNumber; }
 
    constexpr bool isValid() const { return addresses.valid; }
 
    constexpr explicit operator bool() const { return isValid(); }
 
    static bool matchSingle(const MIDICNChannelAddress &toMatch,
                            const MIDICNChannelAddress &base);
 
    static bool matchAddressInRange(const MIDICNChannelAddress &toMatch,
                                    const MIDICNChannelAddress &base,
                                    uint8_t length);
 
    constexpr static MIDICNChannelAddress invalid() { return {}; }
 
  private:
    RawMIDICNChannelAddress addresses;
};
 
END_CS_NAMESPACE