use core::fmt;
use crate::error::Result;
use crate::ids::{Bank, DeviceId, ProgramNumber, Slot};
use crate::param::NrpnEdit;
use crate::sysex::{Frame, Message, inquiry};
use crate::wire::Channel;
pub const MAX_OUTBOUND_LEN: usize = 16;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub enum Request {
Identity,
ControlApp,
EditBuffer,
Program(Slot),
Bank {
bank: Bank,
first: ProgramNumber,
last: ProgramNumber,
},
}
impl fmt::Display for Request {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Identity => f.write_str("device inquiry"),
Self::ControlApp => f.write_str("control app notification"),
Self::EditBuffer => f.write_str("edit buffer dump"),
Self::Program(slot) => write!(f, "program dump {slot}"),
Self::Bank { bank, first, last } => {
write!(f, "program dumps {bank}{first} through {bank}{last}")
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum Outbound {
Ask(Request),
Edit(NrpnEdit),
}
impl Outbound {
pub(super) const fn request(self) -> Option<Request> {
match self {
Self::Ask(request) => Some(request),
Self::Edit(_) => None,
}
}
pub(super) fn encode_into(
self,
device: DeviceId,
channel: Channel,
out: &mut [u8],
) -> Result<usize> {
let message = match self {
Self::Edit(edit) => return edit.encode_into(channel, out),
Self::Ask(Request::Identity) => return inquiry::request_into(device, out),
Self::Ask(Request::ControlApp) => Message::ControlAppNotifyRequest { reserved: 0 },
Self::Ask(Request::EditBuffer) => Message::EditBufferDumpRequest,
Self::Ask(Request::Program(slot)) => Message::ProgramDumpRequest {
bank: slot.bank,
program: slot.number,
},
Self::Ask(Request::Bank { bank, first, last }) => {
Message::ProgramBankDumpRequest { bank, first, last }
}
};
Frame::new(device, message).encode_into(out)
}
}
#[cfg(test)]
mod tests {
use super::{MAX_OUTBOUND_LEN, Outbound, Request};
use crate::ids::{Bank, DeviceId, ProgramNumber, Slot};
use crate::param::{NrpnEdit, ParamId};
use crate::wire::Channel;
fn encoded(item: Outbound) -> usize {
let mut out = [0; MAX_OUTBOUND_LEN];
item.encode_into(DeviceId::Unit(0), Channel::ONE, &mut out)
.unwrap_or(0)
}
#[test]
fn every_outbound_item_fits_the_scratch_buffer() {
let slot = Slot::new(Bank::H, ProgramNumber::LAST);
let items = [
Outbound::Ask(Request::Identity),
Outbound::Ask(Request::ControlApp),
Outbound::Ask(Request::EditBuffer),
Outbound::Ask(Request::Program(slot)),
Outbound::Ask(Request::Bank {
bank: Bank::H,
first: ProgramNumber::FIRST,
last: ProgramNumber::LAST,
}),
Outbound::Edit(NrpnEdit {
parameter: ParamId::Lfo1Rate,
value: 127,
}),
];
for item in items {
let len = encoded(item);
assert!(len > 0, "{item:?} did not encode");
assert!(len <= MAX_OUTBOUND_LEN, "{item:?} needed {len} bytes");
}
}
#[test]
fn only_a_request_starts_one() {
assert_eq!(
Outbound::Ask(Request::EditBuffer).request(),
Some(Request::EditBuffer)
);
assert_eq!(
Outbound::Edit(NrpnEdit {
parameter: ParamId::Lfo1Rate,
value: 0
})
.request(),
None
);
}
#[test]
fn an_edit_buffer_request_is_the_frame_the_manual_prints() {
let mut out = [0; MAX_OUTBOUND_LEN];
let len = Outbound::Ask(Request::EditBuffer)
.encode_into(DeviceId::Unit(0), Channel::ONE, &mut out)
.unwrap_or(0);
assert_eq!(
out.get(..len),
Some(&[0xF0, 0x00, 0x20, 0x32, 0x20, 0x00, 0x03, 0xF7][..])
);
}
}