use super::frame::{Frame, FrameError, FRAME_LEN};
#[derive(Debug, Clone, Copy)]
pub struct FrameAssembler {
buf: [u8; FRAME_LEN],
last: [u8; FRAME_LEN],
filled: usize,
resync: bool,
}
impl FrameAssembler {
pub const fn new() -> Self {
FrameAssembler {
buf: [0; FRAME_LEN],
last: [0; FRAME_LEN],
filled: 0,
resync: false,
}
}
pub const fn resyncing() -> Self {
FrameAssembler {
buf: [0; FRAME_LEN],
last: [0; FRAME_LEN],
filled: 0,
resync: true,
}
}
pub fn reset(&mut self) {
self.filled = 0;
}
pub fn push(&mut self, byte: u8) -> Option<Result<Frame, FrameError>> {
if self.filled >= FRAME_LEN {
self.filled = 0;
}
self.buf[self.filled] = byte;
self.filled += 1;
if self.filled < FRAME_LEN {
return None;
}
let window = self.buf;
self.last = window;
let result = Frame::from_bytes(window);
let slide = self.resync && matches!(result, Err(FrameError::InvalidType(_)));
if slide {
self.buf[0] = window[1];
self.buf[1] = window[2];
self.buf[2] = window[3];
self.filled = FRAME_LEN - 1;
} else {
self.filled = 0;
}
Some(result)
}
pub const fn last_bytes(&self) -> [u8; FRAME_LEN] {
self.last
}
}
impl Default for FrameAssembler {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::protocol::FrameType;
#[test]
fn yields_none_until_full() {
let mut asm = FrameAssembler::new();
let bytes = Frame::data(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(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(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))));
}
#[test]
fn a_dropped_byte_does_not_pin_the_next_frame() {
let mut asm = FrameAssembler::resyncing();
let good = Frame::data(1, 0x42).to_bytes();
let mut stream = [0u8; 5];
stream[0] = 0x00;
stream[1..].copy_from_slice(&good);
let mut got = None;
for byte in stream {
if let Some(Ok(frame)) = asm.push(byte) {
got = Some(frame);
}
}
assert_eq!(got, Some(Frame::data(1, 0x42)));
}
#[test]
fn a_semantic_reject_keeps_the_next_boundary() {
let header = [FrameType::Ack as u8, 1, 0xFF];
let bad = [
header[0],
header[1],
header[2],
crate::protocol::crc8(&header),
];
let next = Frame::ack(2).to_bytes();
let mut asm = FrameAssembler::resyncing();
let mut saw_semantics = false;
let mut got = None;
for byte in bad.into_iter().chain(next) {
match asm.push(byte) {
Some(Err(FrameError::InvalidSemantics)) => saw_semantics = true,
Some(Ok(frame)) => got = Some(frame),
_ => {}
}
}
assert!(saw_semantics);
assert_eq!(got, Some(Frame::ack(2)));
}
#[test]
fn a_crc_miss_does_not_shift_the_next_frame() {
let mut bad = Frame::data(1, 0x11).to_bytes();
bad[3] ^= 0xFF;
let good = Frame::data(2, 0x22).to_bytes();
let mut asm = FrameAssembler::resyncing();
let mut saw_crc = false;
let mut got = None;
for byte in bad.into_iter().chain(good) {
match asm.push(byte) {
Some(Err(FrameError::CrcMismatch { .. })) => saw_crc = true,
Some(Ok(frame)) => got = Some(frame),
_ => {}
}
}
assert!(saw_crc);
assert_eq!(got, Some(Frame::data(2, 0x22)));
}
}