Struct ctf::parse::PacketParser

pub struct PacketParser<'cxt, 'data, Endian> { /* private fields */ }

Packet parser.

Thin wrapper around a RawParser over the bytes of the events of the packet. Also stores the packet header. Note that the bytes for the header are not included in the parser’s data. It has already been parsed.

Implementations

impl<'cxt, 'data, Endian> PacketParser<'cxt, 'data, Endian> where
    Parser<'data, Endian>: CanParse<'data>, 

pub fn header(&self) -> &Packet

Header accessor.

pub fn next_event(&mut self) -> Res<Option<(Clock, Event<'data>)>>

Returns the next event of the packet, if any.

Methods from Deref<Target = RawParser<'data>>

pub fn data(&self) -> &'data [u8]

Data accessor.

pub fn take(&mut self, byte_count: usize) -> &'data [u8]

Consumes some bytes from the input, move the cursor at the end of these bytes.

pub fn pos(&self) -> Pos

Position accessor.

pub fn get(&self, pos: Pos) -> Option<u8>

Retrieves the byte at some position.

pub fn backtrack(&mut self, pos: Pos)

Backtracks the parser to a previous position.

Panics

• when pos is greater than the current position.

pub fn is_eof(&self) -> bool

True if the parser is at the end of its input.

pub fn real_position(&self) -> (usize, usize)

Yields the current position and the total length of the input text.

pub fn state(&self) -> String

Yields a single-line, concise description of the current position.

pub fn string(&mut self) -> Res<&'data str>

Parses a string.

pub fn u8_le(&mut self) -> Res<u8>

Parses a u8.

Examples

let data = 213u8.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u8_le().unwrap(), 213);
assert!(parser.is_eof());

pub fn u8_be(&mut self) -> Res<u8>

Parses a u8.

Examples

let data = 213u8.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u8_be().unwrap(), 213);
assert!(parser.is_eof());

pub fn u16_le(&mut self) -> Res<u16>

Parses a u16.

Examples

let data = 1_213u16.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u16_le().unwrap(), 1_213);
assert!(parser.is_eof());

pub fn u16_be(&mut self) -> Res<u16>

Parses a u16.

Examples

let data = 1_213u16.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u16_be().unwrap(), 1_213);
assert!(parser.is_eof());

pub fn u32_le(&mut self) -> Res<u32>

Parses a u32.

Examples

let data = 1_701_213u32.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u32_le().unwrap(), 1_701_213);
assert!(parser.is_eof());

pub fn u32_be(&mut self) -> Res<u32>

Parses a u32.

Examples

let data = 1_701_213u32.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u32_be().unwrap(), 1_701_213);
assert!(parser.is_eof());

pub fn u64_be(&mut self) -> Res<u64>

Parses a u64.

Examples

let data = 7_501_701_213u64.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u64_be().unwrap(), 7_501_701_213);
assert!(parser.is_eof());

pub fn u64_le(&mut self) -> Res<u64>

Parses a u64, low-endian version.

Examples

let data = 7_501_701_213u64.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u64_le().unwrap(), 7_501_701_213);
assert!(parser.is_eof());

pub fn f64_be(&mut self) -> Res<f64>

Parses a u64, big-endian version.

Examples

let data = 7_501_701.745f64.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.f64_be().unwrap(), 7_501_701.745);
assert!(parser.is_eof());

pub fn f64_le(&mut self) -> Res<f64>

Parses a u64, big-endian version.

Examples

let data = 7_501_701.745f64.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.f64_le().unwrap(), 7_501_701.745);
assert!(parser.is_eof());

pub fn magic(&mut self) -> Res<()>

Parses and checks the CTF magic number, and sets the big-endian flag.

Trait Implementations

impl<'cxt, 'data, Endian> Deref for PacketParser<'cxt, 'data, Endian>

type Target = Parser<'data, Endian>

The resulting type after dereferencing.

fn deref(&self) -> &Parser<'data, Endian>

Dereferences the value.

impl<'cxt, 'data, Endian> DerefMut for PacketParser<'cxt, 'data, Endian>

fn deref_mut(&mut self) -> &mut Parser<'data, Endian>

Mutably dereferences the value.