use core::iter::FusedIterator;
use core::{error, fmt};
const HEADER_LENGTH: usize = 3;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TlvEntry<'a> {
pub tag: u8,
pub value: &'a [u8],
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum TlvError {
TruncatedHeader,
TruncatedValue,
}
impl fmt::Display for TlvError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Self::TruncatedHeader => "the header of an entry is truncated",
Self::TruncatedValue => "the value of an entry is truncated",
})
}
}
impl error::Error for TlvError {}
#[derive(Clone, Debug)]
pub struct TlvEntries<'a> {
rest: &'a [u8],
}
impl<'a> TlvEntries<'a> {
#[must_use]
pub const fn new(bytes: &'a [u8]) -> Self {
Self { rest: bytes }
}
}
impl<'a> Iterator for TlvEntries<'a> {
type Item = Result<TlvEntry<'a>, TlvError>;
fn next(&mut self) -> Option<Self::Item> {
if self.rest.is_empty() {
return None;
}
let result = match self.rest.split_first_chunk::<HEADER_LENGTH>() {
Some((&[tag, low, high], rest)) => {
match rest.split_at_checked(usize::from(u16::from_le_bytes([low, high]))) {
Some((value, rest)) => {
self.rest = rest;
return Some(Ok(TlvEntry { tag, value }));
}
None => Err(TlvError::TruncatedValue),
}
}
None => Err(TlvError::TruncatedHeader),
};
self.rest = &[];
Some(result)
}
}
impl FusedIterator for TlvEntries<'_> {}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn entries_are_views_into_the_stream() {
let bytes = [0x01, 0x02, 0x00, 0xaa, 0xbb, 0x07, 0x00, 0x00];
let mut parser = TlvEntries::new(&bytes);
assert_eq!(
parser.next(),
Some(Ok(TlvEntry {
tag: 1,
value: &[0xaa, 0xbb]
}))
);
assert_eq!(parser.next(), Some(Ok(TlvEntry { tag: 7, value: &[] })));
assert_eq!(parser.next(), None);
}
#[test]
fn truncation_ends_the_iteration() {
let mut parser = TlvEntries::new(&[0x01, 0x02]);
assert_eq!(parser.next(), Some(Err(TlvError::TruncatedHeader)));
assert_eq!(parser.next(), None);
let mut parser = TlvEntries::new(&[0x01, 0x02, 0x00, 0xaa]);
assert_eq!(parser.next(), Some(Err(TlvError::TruncatedValue)));
assert_eq!(parser.next(), None);
}
}