Struct rxml::AsyncDriver

pub struct AsyncDriver<T, P: Parse> { /* private fields */ }

Asynchronous driver for parsers

This is a generic asynchronous driver for objects implementing the Parse trait.

In general, it is advised to use the AsyncParser alias which specializes this struct for use with the default Parser.

Implementations

impl<T: AsyncBufRead, P: Parse + Default> AsyncDriver<T, P>

pub fn new(inner: T) -> Self

Create a new parser with default options, wrapping the given reader.

pub fn with_options(inner: T, options: LexerOptions) -> Self

Create a new parser while configuring the lexer with the given options.

impl<T: AsyncBufRead, P: Parse> AsyncDriver<T, P>

pub fn wrap(inner: T, lexer: Lexer, parser: P) -> Self

Create a fully customized parser from a lexer and a parser component.

pub fn into_inner(self) -> (T, Lexer, P)

Decompose the AsyncDriver into its parts

pub fn get_inner(&self) -> &T

Access the inner AsyncBufRead

pub fn get_inner_mut(&mut self) -> &mut T

Access the inner AsyncBufRead, mutably

pub fn get_lexer(&self) -> &Lexer

Access the lexer

pub fn get_lexer_mut(&mut self) -> &mut Lexer

Access the lexer, mutably

pub fn get_parser(&self) -> &P

Access the parser

pub fn get_parser_mut(&mut self) -> &mut P

Access the parser, mutably

pub fn release_temporaries(&mut self)

Release temporary buffers and other ephemeral allocations.

This is sensible to call when it is expected that no more data will be processed by the parser for a while and the memory is better used elsewhere.

Trait Implementations

impl<T: AsyncBufRead, P: Parse> AsyncEventRead for AsyncDriver<T, P>

type Output = P::Output

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<Option<P::Output>>>

Poll for a single event from the parser.

impl<T: AsyncBufRead, P: Parse + Default> Stream for AsyncDriver<T, P>

type Item = Result<P::Output>

Values yielded by the stream.

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'__pin, T, P: Parse> Unpin for AsyncDriver<T, P> where
    __Origin<'__pin, T, P>: Unpin,