Struct mbon::async_wrapper::AsyncParser

pub struct AsyncParser<R>(_);

A wrapper for Parser.

AsyncParser reads from the reader into a buffer where Parser can parse the requested data. Every request for data will ask for exactly what’s needed to perform the task.

Example

use futures::io::Cursor;

use mbon::async_wrapper::AsyncParser;

let reader = Cursor::new(b"i\x00\x00\x00\x0f");
let mut parser = AsyncParser::from(reader);

let val: u32 = parser.next().await?;

assert_eq!(val, 15);

Implementations

impl<R> AsyncParser<R>where
    R: AsyncReadExt + Unpin + Send,

pub fn reader(self) -> R

Turn the parser into the underlying reader

pub fn get_reader(&self) -> &R

Get the underlying reader as a reference

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

Get the underlying reader as a mutable reference

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

Parse the next item in the parser.

pub async 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

see Parser::next_obj()

pub async 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.

see Parser::skip_next()

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

Parse the next value in the parser.

see Parser::next_value()

impl<R> AsyncParser<R>where
    R: AsyncReadExt + AsyncSeekExt + Unpin + Send,

pub async 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

see Parser::seek_next()

Trait Implementations

impl<R> AsMut<R> for AsyncParser<R>

fn as_mut(&mut self) -> &mut R

Converts this type into a mutable reference of the (usually inferred) input type.

impl<R> AsRef<R> for AsyncParser<R>

fn as_ref(&self) -> &R

Converts this type into a shared reference of the (usually inferred) input type.

impl<R: Debug> Debug for AsyncParser<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R> From<R> for AsyncParser<R>where
    R: AsyncReadExt + Unpin + Send,

fn from(reader: R) -> Self

Converts to this type from the input type.