Struct mbon::parser::Parser

source ·

pub struct Parser<R>(_);

Expand description

A struct that parses binary data from a bytearray

You can deserialize data using

Or you can deserialize data directly using

next_value()

Implementations

source

impl<R> Parser<R>where
R: Read,

source

pub fn reader(self) -> R

Turn the parser into the underlying reader

source

pub fn get_reader(&self) -> &R

Get the the underlying reader as a reference

source

pub fn get_reader_mut(&mut self) -> &mut R

Get the the underlying reader as a mutable reference

source

pub fn next<T>(&mut self) -> Result<T>where
T: DeserializeOwned,

Parse the next item in the parser.

Example

use mbon::parser::Parser;

let mut parser = Parser::from(b"i\x00\x00\x00\x42");
let i: u32 = parser.next().unwrap();

assert_eq!(i, 0x42);

source

pub fn next_obj<T>(&mut self) -> Result<T>where
T: ObjectParse,
<T as ObjectParse>::Error: Error + 'static,

Parse the next custom object in the parser.

This allows you to be able to parse custom binary data. A common usecase is to store a struct in a more compact form. You could also use object values to store a different format altogether.

Note: the next value in the parser must be an Object

Example

use mbon::error::Error;
use mbon::parser::Parser;
use mbon::object::ObjectParse;

struct Foo {
    a: i32,
    b: String,
    c: f32,
}

impl ObjectParse for Foo {
    type Error = Error;

    fn parse_object(data: &[u8]) -> Result<Self, Self::Error> {
        let mut parser = Parser::from(data);
        let a = parser.next()?;
        let b = parser.next()?;
        let c = parser.next()?;
        Ok(Self { a, b, c })
    }
}

let mut parser =
Parser::from(
    b"o\x00\x00\x00\x14i\x00\x00\x00\x42s\x00\x00\x00\x05Hellof\x00\x00\x00\x00"
);

let foo: Foo = parser.next_obj().unwrap();
assert_eq!(foo.a, 0x42);
assert_eq!(foo.b, "Hello");
assert_eq!(foo.c, 0.0);

source

pub fn skip_next(&mut self) -> Result<()>

Skip the next value in the parser.

This will ignore the next value without parsing more than what’s necessary.

If the reader supports seeking, then it is preffered to use seek_next() instead.

Example

use mbon::parser::Parser;

let mut parser = Parser::from(
    b"s\x00\x00\x00\x1eI don't care about this stringi\x00\x00\x00\x42"
);

parser.skip_next().unwrap();

let v: i32 = parser.next().unwrap();
assert_eq!(v, 0x42);

source

pub fn next_value(&mut self) -> Result<Value>

Parse the next value in the parser.

This will try to read whatever value is next and return it.

Example

use mbon::parser::Parser;
use mbon::data::Value;

let mut parser = Parser::from(b"i\x00\x00\x00\x42");

assert_eq!(parser.next_value().unwrap(), Value::Int(0x42));

source

impl<R> Parser<R>where
R: Read + Seek,

source

pub fn seek_next(&mut self) -> Result<()>

Seek to the next value in the parser.

This will efficiently skip the next value without reading more than what’s necessary.

Example

use mbon::parser::Parser;
use std::io::Cursor;

let reader = Cursor::new(
    b"s\x00\x00\x00\x23This is a string I don't care abouti\x00\x00\x00\x20"
);

let mut parser = Parser::from(reader);

parser.seek_next().unwrap();
let val: u32 = parser.next().unwrap();

assert_eq!(val, 32);