use core::iter::FusedIterator;
use crate::error::{Error, Result};
use crate::ids::Slot;
use crate::program::Program;
use crate::sysex::{Frame, Message};
use crate::wire::{SYSEX_END, SYSEX_START};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Entry {
pub slot: Option<Slot>,
pub program: Program,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct File<'a> {
bytes: &'a [u8],
}
impl<'a> File<'a> {
#[must_use]
pub const fn new(bytes: &'a [u8]) -> Self {
Self { bytes }
}
#[must_use]
pub const fn as_bytes(&self) -> &'a [u8] {
self.bytes
}
#[must_use]
pub const fn frames(&self) -> Frames<'a> {
Frames::new(self.bytes)
}
#[must_use]
pub const fn programs(&self) -> Programs<'a> {
Programs::new(self.bytes)
}
}
#[derive(Debug, Clone)]
pub struct Frames<'a> {
bytes: &'a [u8],
pos: usize,
offset: usize,
done: bool,
}
impl<'a> Frames<'a> {
#[must_use]
pub const fn new(bytes: &'a [u8]) -> Self {
Self {
bytes,
pos: 0,
offset: 0,
done: false,
}
}
#[must_use]
pub const fn offset(&self) -> usize {
self.offset
}
}
impl<'a> Iterator for Frames<'a> {
type Item = Result<Frame<'a>>;
fn next(&mut self) -> Option<Self::Item> {
if self.done {
return None;
}
let rest = self.bytes.get(self.pos..)?;
let start = self
.pos
.saturating_add(rest.iter().position(|byte| *byte == SYSEX_START)?);
let frame = self.bytes.get(start..)?;
self.offset = start;
let Some(end) = frame
.iter()
.skip(1)
.position(|byte| *byte == SYSEX_END || *byte == SYSEX_START)
.map(|index| index.saturating_add(1))
else {
self.done = true;
self.pos = self.bytes.len();
return Some(Err(Error::Unframed));
};
if frame.get(end) == Some(&SYSEX_START) {
self.pos = start.saturating_add(end);
return Some(Err(Error::Unframed));
}
self.pos = start.saturating_add(end).saturating_add(1);
Some(Frame::parse(frame.get(..=end)?))
}
}
impl FusedIterator for Frames<'_> {}
#[derive(Debug, Clone)]
pub struct Programs<'a> {
frames: Frames<'a>,
}
impl<'a> Programs<'a> {
#[must_use]
pub const fn new(bytes: &'a [u8]) -> Self {
Self {
frames: Frames::new(bytes),
}
}
#[must_use]
pub const fn offset(&self) -> usize {
self.frames.offset()
}
}
impl Iterator for Programs<'_> {
type Item = Result<Entry>;
fn next(&mut self) -> Option<Self::Item> {
loop {
let frame = match self.frames.next()? {
Ok(frame) => frame,
Err(error) => return Some(Err(error)),
};
let (slot, version, packed) = match frame.message {
Message::ProgramDumpResponse {
version,
bank,
program,
packed,
} => (Some(Slot::new(bank, program)), version, packed),
Message::EditBufferDumpResponse { version, packed } => (None, version, packed),
_ => continue,
};
return Some(
Program::from_packed(version, packed).map(|program| Entry { slot, program }),
);
}
}
}
impl FusedIterator for Programs<'_> {}
#[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::{Bank, DeviceId, ProgramNumber, ProtocolVersion};
use crate::program::ProgramName;
use crate::syx::{MAX_PROGRAM_FRAME_LEN, Writer, bank_to_vec, program_frame_len};
fn named(name: &str) -> Program {
let mut program = Program::new(ProtocolVersion::V6);
program.set_name(ProgramName::new(name).expect("a name the display can show"));
program
}
fn pack(programs: &[Program]) -> Vec<u8> {
bank_to_vec(DeviceId::Unit(0), Bank::A, ProgramNumber::FIRST, programs)
.expect("a bank that fits")
}
#[test]
fn a_file_hands_back_the_programs_put_into_it() {
let written = [named("One"), named("Two"), named("Three")];
let bytes = pack(&written);
let read: Vec<Entry> = File::new(&bytes)
.programs()
.collect::<Result<_>>()
.expect("every program parses");
assert_eq!(read.len(), 3);
for (index, (entry, program)) in read.iter().zip(&written).enumerate() {
assert_eq!(&entry.program, program);
assert_eq!(
entry.slot,
Some(Slot::new(
Bank::A,
ProgramNumber::new(u8::try_from(index).expect("a small index"))
.expect("a program in range")
))
);
}
}
#[test]
fn an_empty_file_holds_nothing() {
assert_eq!(File::new(&[]).frames().count(), 0);
assert_eq!(File::new(&[]).programs().count(), 0);
}
#[test]
fn bytes_between_frames_are_skipped() {
let bytes = pack(&[named("One")]);
let mut padded = alloc::vec![0x00, 0x00];
padded.extend_from_slice(&bytes);
padded.extend_from_slice(&[0x00, 0x00, 0x00]);
let entries: Vec<Entry> = File::new(&padded)
.programs()
.collect::<Result<_>>()
.expect("the frame between the padding");
let entry = entries.first().expect("the one program");
assert_eq!(entries.len(), 1);
assert_eq!(entry.program.name().as_str(), "One");
}
#[test]
fn an_unclosed_frame_is_reported_where_it_starts() {
let bytes = pack(&[named("One"), named("Two")]);
let truncated = bytes.get(..bytes.len() - 1).expect("a shortened file");
let mut frames = File::new(truncated).frames();
assert!(frames.next().expect("the first frame").is_ok());
assert_eq!(frames.offset(), 0);
assert_eq!(frames.next(), Some(Err(Error::Unframed)));
assert_eq!(frames.offset(), program_frame_len(&named("One")));
assert_eq!(frames.next(), None, "nothing follows an unclosed frame");
}
#[test]
fn frames_carrying_no_program_are_skipped() {
let mut bytes = Vec::new();
bytes.extend_from_slice(
&Frame::new(DeviceId::Unit(0), Message::EditBufferDumpRequest).to_vec(),
);
bytes.extend_from_slice(&pack(&[named("One")]));
bytes.extend_from_slice(
&Frame::new(DeviceId::Unit(0), Message::GlobalParameterDumpRequest).to_vec(),
);
assert_eq!(File::new(&bytes).frames().count(), 3);
let entries: Vec<Entry> = File::new(&bytes)
.programs()
.collect::<Result<_>>()
.expect("the one program");
assert_eq!(entries.len(), 1);
}
#[test]
fn an_edit_buffer_dump_is_a_program_without_a_slot() {
let program = named("Edit");
let mut bytes = [0; MAX_PROGRAM_FRAME_LEN];
let mut writer = Writer::new(&mut bytes, DeviceId::Unit(0));
writer
.push_edit_buffer(&program)
.expect("room for one program");
let written = writer.finish();
let entry = File::new(bytes.get(..written).expect("what was written"))
.programs()
.next()
.expect("one program")
.expect("it parses");
assert_eq!(entry.slot, None);
assert_eq!(entry.program, program);
}
#[test]
fn a_truncated_frame_does_not_take_the_one_after_it() {
let whole = pack(&[named("One")]);
let mut bytes = whole.get(..100).expect("a frame is longer").to_vec();
bytes.extend_from_slice(&whole);
let mut programs = File::new(&bytes).programs();
assert_eq!(programs.next(), Some(Err(Error::Unframed)));
assert_eq!(programs.offset(), 0);
let entry = programs
.next()
.expect("the whole frame")
.expect("it parses");
assert_eq!(entry.program.name().as_str(), "One");
assert_eq!(programs.offset(), 100);
assert_eq!(programs.next(), None);
}
#[test]
fn a_foreign_frame_is_an_error_and_the_walk_goes_on() {
let mut bytes = alloc::vec![0xF0, 0x43, 0x10, 0x20, 0x00, 0x01, 0x02, 0xF7];
bytes.extend_from_slice(&pack(&[named("One")]));
let mut programs = File::new(&bytes).programs();
assert_eq!(
programs.next(),
Some(Err(Error::Foreign {
manufacturer: [0x43, 0x10, 0x20],
model: 0x00,
}))
);
let entry = programs
.next()
.expect("the DeepMind frame after it")
.expect("it parses");
assert_eq!(entry.program.name().as_str(), "One");
}
}