use super::ParseError;
pub trait Packed: Sized {
const STRUCTURE: &'static str;
const HEAD: usize;
fn read_head(buf: &[u8]) -> Result<Self, ParseError>;
fn encoded_len(&self) -> usize;
}
pub fn for_each_packed<T: Packed, F>(data: &[u8], mut visit: F) -> Result<(), ParseError>
where
F: FnMut(&T, &[u8]) -> bool,
{
let mut at = 0usize;
while at < data.len() {
let record = T::read_head(&data[at..])?;
let len = record.encoded_len();
let end = at + len;
if end > data.len() {
return Err(ParseError::TooShort {
structure: T::STRUCTURE,
need: len,
got: data.len() - at,
});
}
if !visit(&record, &data[at + T::HEAD..end]) {
return Ok(());
}
at = end;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
struct Run(u8);
impl Packed for Run {
const STRUCTURE: &'static str = "run";
const HEAD: usize = 1;
fn read_head(buf: &[u8]) -> Result<Self, ParseError> {
match buf.first() {
Some(&n) => Ok(Self(n)),
None => Err(ParseError::TooShort {
structure: Self::STRUCTURE,
need: 1,
got: 0,
}),
}
}
fn encoded_len(&self) -> usize {
Self::HEAD + self.0 as usize
}
}
fn tails(data: &[u8]) -> Result<Vec<Vec<u8>>, ParseError> {
let mut out = Vec::new();
for_each_packed::<Run, _>(data, |_, tail| {
out.push(tail.to_vec());
true
})?;
Ok(out)
}
#[test]
fn every_record_packed_into_one_item_is_framed_in_order() {
let data = [3u8, b'a', b'b', b'c', 0, 1, b'z'];
assert_eq!(
tails(&data).expect("three records"),
vec![b"abc".to_vec(), Vec::new(), b"z".to_vec()]
);
assert_eq!(tails(&[]).expect("no records"), Vec::<Vec<u8>>::new());
}
#[test]
fn a_record_whose_tail_escapes_the_item_is_refused_rather_than_shortened() {
let err = tails(&[3u8, b'a', b'b']).expect_err("a tail one byte past the item");
assert!(matches!(
err,
ParseError::TooShort {
structure: "run",
need: 4,
got: 3,
}
));
}
#[test]
fn a_visitor_that_has_found_what_it_wanted_stops_the_framing_there() {
let mut seen = Vec::new();
for_each_packed::<Run, _>(&[1u8, b'a', 1, b'b'], |_, tail| {
seen.push(tail[0]);
false
})
.expect("one record");
assert_eq!(seen, vec![b'a']);
}
}