#[cfg(feature = "alloc")]
use alloc::vec::Vec;
#[cfg(feature = "alloc")]
use crate::error::Error;
use crate::error::Result;
use crate::ids::{Bank, DeviceId, PROGRAMS_PER_BANK, ProgramNumber};
use crate::program::Program;
use crate::sysex::{Frame, Message, OVERHEAD_LEN};
const PROGRAM_PREFIX_LEN: usize = 3;
const EDIT_BUFFER_PREFIX_LEN: usize = 1;
pub const MAX_PROGRAM_FRAME_LEN: usize =
OVERHEAD_LEN + PROGRAM_PREFIX_LEN + Program::PACKED_MAX_LEN;
pub const MAX_BANK_LEN: usize = MAX_PROGRAM_FRAME_LEN * PROGRAMS_PER_BANK as usize;
#[must_use]
pub fn program_frame_len(program: &Program) -> usize {
OVERHEAD_LEN + PROGRAM_PREFIX_LEN + program.packed_len()
}
#[must_use]
pub fn edit_buffer_frame_len(program: &Program) -> usize {
OVERHEAD_LEN + EDIT_BUFFER_PREFIX_LEN + program.packed_len()
}
#[derive(Debug)]
pub struct Writer<'a> {
out: &'a mut [u8],
written: usize,
device: DeviceId,
}
impl<'a> Writer<'a> {
#[must_use]
pub const fn new(out: &'a mut [u8], device: DeviceId) -> Self {
Self {
out,
written: 0,
device,
}
}
#[must_use]
pub const fn device(&self) -> DeviceId {
self.device
}
#[must_use]
pub const fn written(&self) -> usize {
self.written
}
#[must_use]
pub fn as_bytes(&self) -> &[u8] {
self.out.get(..self.written).unwrap_or_default()
}
pub fn push(&mut self, message: Message<'_>) -> Result<usize> {
let frame = Frame::new(self.device, message);
let rest = self.out.get_mut(self.written..).unwrap_or_default();
let len = frame.encode_into(rest)?;
self.written = self.written.saturating_add(len);
Ok(len)
}
pub fn push_program(
&mut self,
bank: Bank,
number: ProgramNumber,
program: &Program,
) -> Result<usize> {
let mut packed = [0; Program::PACKED_MAX_LEN];
let len = program.pack_into(&mut packed)?;
self.push(Message::ProgramDumpResponse {
version: program.version(),
bank,
program: number,
packed: packed.get(..len).unwrap_or_default(),
})
}
pub fn push_edit_buffer(&mut self, program: &Program) -> Result<usize> {
let mut packed = [0; Program::PACKED_MAX_LEN];
let len = program.pack_into(&mut packed)?;
self.push(Message::EditBufferDumpResponse {
version: program.version(),
packed: packed.get(..len).unwrap_or_default(),
})
}
#[must_use]
pub const fn finish(self) -> usize {
self.written
}
}
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
pub fn bank_to_vec(
device: DeviceId,
bank: Bank,
first: ProgramNumber,
programs: &[Program],
) -> Result<Vec<u8>> {
let last = usize::from(first.get())
.saturating_add(programs.len())
.saturating_sub(1);
if !programs.is_empty() && last >= usize::from(PROGRAMS_PER_BANK) {
return Err(Error::ProgramOutOfRange(
u8::try_from(last).unwrap_or(u8::MAX),
));
}
let mut out = alloc::vec![0; programs.len().saturating_mul(MAX_PROGRAM_FRAME_LEN)];
let mut writer = Writer::new(&mut out, device);
for (index, program) in programs.iter().enumerate() {
let number = ProgramNumber::new(
first
.get()
.saturating_add(u8::try_from(index).unwrap_or(u8::MAX)),
)?;
writer.push_program(bank, number, program)?;
}
let written = writer.finish();
out.truncate(written);
Ok(out)
}
#[cfg(all(test, feature = "alloc"))]
#[expect(
clippy::expect_used,
reason = "a failed expectation is the test failure"
)]
mod tests {
use alloc::vec::Vec;
use super::*;
use crate::ids::ProtocolVersion;
use crate::syx::File;
fn program() -> Program {
Program::new(ProtocolVersion::V6)
}
fn bank_c() -> Bank {
Bank::new(2).expect("a bank in range")
}
#[test]
fn the_stated_lengths_are_what_the_encoder_writes() {
let program = program();
let mut packed = [0; Program::PACKED_MAX_LEN];
let len = program.pack_into(&mut packed).expect("room to pack");
let packed = packed.get(..len).expect("what was packed");
let stored = Frame::new(
DeviceId::Unit(0),
Message::ProgramDumpResponse {
version: program.version(),
bank: Bank::A,
program: ProgramNumber::FIRST,
packed,
},
);
assert_eq!(stored.encoded_len(), program_frame_len(&program));
let edit = Frame::new(
DeviceId::Unit(0),
Message::EditBufferDumpResponse {
version: program.version(),
packed,
},
);
assert_eq!(edit.encoded_len(), edit_buffer_frame_len(&program));
assert!(program_frame_len(&program) <= MAX_PROGRAM_FRAME_LEN);
}
#[test]
fn a_full_bank_fits_the_stated_maximum() {
let programs = alloc::vec![program(); usize::from(PROGRAMS_PER_BANK)];
let bytes = bank_to_vec(
DeviceId::Broadcast,
Bank::A,
ProgramNumber::FIRST,
&programs,
)
.expect("a bank that fits");
assert!(bytes.len() <= MAX_BANK_LEN);
assert_eq!(File::new(&bytes).programs().count(), 128);
}
#[test]
fn a_bank_that_would_run_past_its_end_is_refused() {
let programs = alloc::vec![program(); 2];
assert_eq!(
bank_to_vec(DeviceId::Unit(0), Bank::A, ProgramNumber::LAST, &programs),
Err(Error::ProgramOutOfRange(128))
);
}
#[test]
fn no_programs_is_an_empty_file() {
let bytes = bank_to_vec(DeviceId::Unit(0), Bank::A, ProgramNumber::LAST, &[])
.expect("nothing to write");
assert!(bytes.is_empty());
}
#[test]
fn a_buffer_too_small_writes_nothing_further() {
let program = program();
let mut bytes = [0; MAX_PROGRAM_FRAME_LEN + 4];
let mut writer = Writer::new(&mut bytes, DeviceId::Unit(0));
writer
.push_program(Bank::A, ProgramNumber::FIRST, &program)
.expect("room for the first");
let after_first = writer.written();
let full = program_frame_len(&program);
assert_eq!(
writer.push_program(Bank::A, ProgramNumber::FIRST, &program),
Err(Error::BufferTooSmall {
needed: full,
available: 4,
})
);
assert_eq!(writer.written(), after_first);
assert_eq!(File::new(writer.as_bytes()).programs().count(), 1);
}
#[test]
fn what_is_written_is_what_is_read_back() {
let program = program();
let mut bytes = alloc::vec![0; MAX_BANK_LEN];
let mut writer = Writer::new(&mut bytes, DeviceId::Broadcast);
writer
.push_edit_buffer(&program)
.expect("room for the edit buffer");
writer
.push_program(
bank_c(),
ProgramNumber::new(7).expect("a program"),
&program,
)
.expect("room for the program");
let entries: Vec<_> = File::new(writer.as_bytes())
.programs()
.collect::<Result<_>>()
.expect("both parse");
assert_eq!(entries.len(), 2);
let edit = entries.first().expect("the edit buffer");
let stored = entries.get(1).expect("the stored program");
assert_eq!(edit.slot, None);
assert_eq!(stored.slot.map(|slot| slot.bank), Some(bank_c()));
assert!(entries.iter().all(|entry| entry.program == program));
}
}