Struct yatlv::FrameParser

pub struct FrameParser<'a> { /* fields omitted */ }

FrameParser can be used to access field encoded as a frame.

Implementations

impl<'a> FrameParser<'a>

pub fn new(frame_data: &[u8]) -> Result<FrameParser<'_>>

// Assuming frame_data contains a frame with a single data field (tag=12, value=[4, 5])
let parser = FrameParser::new(&frame_data)?;
let expected: &[u8] = &[4, 5];
assert_eq!(Some(expected), parser.get_data(12));

pub fn get_data(&self, search_tag: u16) -> Option<&'a [u8]>

Read field from frame.

// Assuming frame_data contains a frame with a single data field (tag=12, value=[4, 5])
let parser = FrameParser::new(&frame_data)?;
let expected: &[u8] = &[4, 5];
assert_eq!(Some(expected), parser.get_data(12));

pub fn get_datas<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = &'a [u8]> where
    'b: 'a, 

Read fields from frame.

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1=[4, 5], value2=[3, 5])
let parser = FrameParser::new(&frame_data)?;
let expected = vec![&[4, 5], &[3, 5]];
let actual: Vec<&[u8]> =  parser.get_datas(12).collect();
assert_eq!(expected, actual);

pub fn get_u8(&self, search_tag: u16) -> Result<Option<u8>>

Read u8 field from frame

Can handle data stored a 1, 2, 4 or 8 bytes, so long as the value is small enough to be returned in a u8.

// Assuming frame_data contains a frame with a single data field (tag=12, value=9)
let parser = FrameParser::new(&frame_data)?;
assert_eq!(Some(9), parser.get_u8(12)?);

pub fn get_u8s<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<u8>> + 'b where
    'b: 'a, 

Read u8 fields from frame

Can handle data stored a 1, 2, 4 or 8 bytes, so long as the value is small enough to be returned in a u8.

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1=6, value2=9)
let parser = FrameParser::new(&frame_data)?;
let expected : Vec<Result<u8>> = vec![Ok(6), Ok(9)];
let actual: Vec<Result<u8>> = parser.get_u8s(12).collect();
assert_eq!(expected, actual);

pub fn get_u16(&self, search_tag: u16) -> Result<Option<u16>>

Read u16 field from frame

Can handle data stored a 1, 2, 4 or 8 bytes, so long as the value is small enough to be returned in a u16.

// Assuming frame_data contains a frame with a single data field (tag=12, value=1024)
let parser = FrameParser::new(&frame_data)?;
assert_eq!(Some(1024), parser.get_u16(12)?);

pub fn get_u16s<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<u16>> + 'b where
    'b: 'a, 

Read u16 fields from frame

Can handle data stored a 1, 2, 4 or 8 bytes, so long as the value is small enough to be returned in a u16.

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1=1024, value2=1025)
let parser = FrameParser::new(&frame_data)?;
let expected : Vec<Result<u16>> = vec![Ok(1024), Ok(1025)];
let actual: Vec<Result<u16>> = parser.get_u16s(12).collect();
assert_eq!(expected, actual);

pub fn get_u32(&self, search_tag: u16) -> Result<Option<u32>>

Read u32 field from frame

Can handle data stored a 1, 2, 4 or 8 bytes, so long as the value is small enough to be returned in a u32.

// Assuming frame_data contains a frame with a
// single data field (tag=12, value=1744964616)
let parser = FrameParser::new(&frame_data)?;
assert_eq!(Some(1744964616), parser.get_u32(12)?);

pub fn get_u32s<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<u32>> + 'b where
    'b: 'a, 

Read u32 fields from frame

Can handle data stored a 1, 2, 4 or 8 bytes, so long as the value is small enough to be returned in a u32.

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1=1744964616, value2=1744964617)
let parser = FrameParser::new(&frame_data)?;
let expected : Vec<Result<u32>> = vec![Ok(1744964616), Ok(1744964617)];
let actual: Vec<Result<u32>> = parser.get_u32s(12).collect();
assert_eq!(expected, actual);

pub fn get_u64(&self, search_tag: u16) -> Result<Option<u64>>

Read u64 field from frame

Can handle data stored a 1, 2, 4 or 8 bytes.

// Assuming frame_data contains a frame with a
// single data field (tag=12, value=150626523450313736)
let parser = FrameParser::new(&frame_data)?;
assert_eq!(Some(150626523450313736), parser.get_u64(12)?);

pub fn get_u64s<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<u64>> + 'b where
    'b: 'a, 

Read u64 fields from frame

Can handle data stored a 1, 2, 4 or 8 bytes.

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1=150626523450313736, value2=150626523450313737)
let parser = FrameParser::new(&frame_data)?;
let expected : Vec<Result<u64>> = vec![Ok(150626523450313736), Ok(150626523450313737)];
let actual: Vec<Result<u64>> = parser.get_u64s(12).collect();
assert_eq!(expected, actual);

pub fn get_bool(&self, search_tag: u16) -> Result<Option<bool>>

Read bool field from frame

// Assuming frame_data contains a frame with a
// single data field (tag=12, value=true)
let parser = FrameParser::new(&frame_data)?;
assert_eq!(Some(true), parser.get_bool(12)?);

pub fn get_bools<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<bool>> + 'b where
    'b: 'a, 

Read bool fields from frame

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1=false, value2=true)
let parser = FrameParser::new(&frame_data)?;
let expected : Vec<Result<bool>> = vec![Ok(false), Ok(true)];
let actual: Vec<Result<bool>> = parser.get_bools(12).collect();
assert_eq!(expected, actual);

pub fn get_str(&self, search_tag: u16) -> Result<Option<&str>>

Read str field from frame

// Assuming frame_data contains a frame with a
// single data field (tag=12, value="test_str" in UTF-8)
let parser = FrameParser::new(&frame_data)?;
assert_eq!(Some("test_str"), parser.get_str(12)?);

pub fn get_strs<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<&'a str>> + 'b where
    'b: 'a, 

Read str fields from frame

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1="hello", value2="goodbye")
let parser = FrameParser::new(&frame_data)?;
let expected : Vec<Result<&str>> = vec![Ok("hello"), Ok("goodbye")];
let actual: Vec<Result<&str>> = parser.get_strs(12).collect();
assert_eq!(expected, actual);

pub fn get_uuid(&self, search_tag: u16) -> Result<Option<Uuid>>

Read uuid field from frame

// Assuming frame_data contains a frame with a
// single data field (tag=12, value=3011712a-d972-4a5d-bbf9-ec5fb7525c97)
let parser = FrameParser::new(&frame_data)?;
let expected = uuid::Uuid::parse_str("3011712a-d972-4a5d-bbf9-ec5fb7525c97").unwrap();
assert_eq!(Some(expected), parser.get_uuid(12)?);

pub fn get_uuids<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<Uuid>> + 'b where
    'b: 'a, 

Read uuid fields from frame

// Assuming frame_data contains a frame with a two fields
// (tag=12, value1=3011712a-d972-4a5d-bbf9-ec5fb7525c97, value2=40b4e52c-1501-48d3-98eb-e2c66cb76cbf)
let parser = FrameParser::new(&frame_data)?;
let expected = vec! [Ok(uuid::Uuid::parse_str("3011712a-d972-4a5d-bbf9-ec5fb7525c97").unwrap()),
                     Ok(uuid::Uuid::parse_str("40b4e52c-1501-48d3-98eb-e2c66cb76cbf").unwrap())];
let actual: Vec<Result<uuid::Uuid>> = parser.get_uuids(12).collect();
assert_eq!(expected, actual);

pub fn get_frame(&self, search_tag: u16) -> Result<Option<FrameParser<'_>>>

Read a child frame from a frame.

// Assuming frame_data contains a frame with a
// child frame (tag=12) which contains a single
// value (tag=13, value=2)
let parser = FrameParser::new(&frame_data)?;
let child_parser = parser.get_frame(12)?.unwrap();
assert_eq!(Some(2), child_parser.get_u8(13)?);

pub fn get_frames<'b>(
    &'b self,
    search_tag: u16
) -> impl Iterator<Item = Result<FrameParser<'a>>> + 'b where
    'b: 'a, 

Read child frames from a frame.

// Assuming frame_data contains a frame with two
// child frame (tag=12) which each contains a single
// value (tag=13, value=2)
let parser = FrameParser::new(&frame_data)?;
let children: Vec<FrameParser> = parser.get_frames(12).map(|v| v.unwrap()).collect();
assert_eq!(2, children.len());
assert_eq!(Some(2), children[0].get_u8(13)?);
assert_eq!(Some(2), children[1].get_u8(13)?);