use super::frame::{Frame, FrameError, FRAME_LEN};
#[derive(Debug, Clone, Copy)]
pub struct FrameAssembler {
buf: [u8; FRAME_LEN],
filled: usize,
}
impl FrameAssembler {
pub const fn new() -> Self {
FrameAssembler {
buf: [0; FRAME_LEN],
filled: 0,
}
}
pub fn reset(&mut self) {
self.filled = 0;
}
pub fn push(&mut self, byte: u8) -> Option<Result<Frame, FrameError>> {
self.buf[self.filled] = byte;
self.filled += 1;
if self.filled < FRAME_LEN {
return None;
}
let result = Frame::from_bytes(self.buf);
self.filled = 0;
Some(result)
}
}
impl Default for FrameAssembler {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn yields_none_until_full() {
let mut asm = FrameAssembler::new();
let bytes = Frame::data_frame(3, 0x55).to_bytes();
assert!(asm.push(bytes[0]).is_none());
assert!(asm.push(bytes[1]).is_none());
assert!(asm.push(bytes[2]).is_none());
assert_eq!(
asm.push(bytes[3]),
Some(Ok(Frame::data_frame(3, 0x55)))
);
}
#[test]
fn resets_after_completion_and_accepts_next_frame() {
let mut asm = FrameAssembler::new();
let first = Frame::ack(1).to_bytes();
let second = Frame::nack(2).to_bytes();
for b in first {
asm.push(b);
}
let mut last = None;
for b in second {
last = asm.push(b);
}
assert_eq!(last, Some(Ok(Frame::nack(2))));
}
#[test]
fn explicit_reset_discards_partial_frame() {
let mut asm = FrameAssembler::new();
asm.push(0xFF);
asm.push(0xFF);
asm.reset();
let bytes = Frame::ack(9).to_bytes();
let mut last = None;
for b in bytes {
last = asm.push(b);
}
assert_eq!(last, Some(Ok(Frame::ack(9))));
}
#[test]
fn propagates_decode_errors_and_still_resets() {
let mut asm = FrameAssembler::new();
let mut bytes = Frame::data_frame(1, 1).to_bytes();
bytes[0] = 0x00; let mut last = None;
for b in bytes {
last = asm.push(b);
}
assert!(matches!(last, Some(Err(_))));
let ok = Frame::ack(5).to_bytes();
let mut last2 = None;
for b in ok {
last2 = asm.push(b);
}
assert_eq!(last2, Some(Ok(Frame::ack(5))));
}
}