Struct GenericAsyncReader 

pub struct GenericAsyncReader<T, P: Parse = Parser> { /* private fields */ }

Available on crate feature tokio only.

Generic tokio-compatible asynchronous driver for restricted XML parsers.

This type is best used through its aliases:

• AsyncReader which uses Parser and provides full XML namespacing support
• AsyncRawReader which uses RawParser and comes with limitations around validity checking and does not support XML namespaces.

The aliases have more extensive usage documentation as well as examples.

Implementations

impl<T, P: Parse + Default> GenericAsyncReader<T, P>

pub fn new(inner: T) -> Self

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

impl<T, P: Parse + WithOptions> GenericAsyncReader<T, P>

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

Create a reader while configuring the parser with the given options.

impl<T, P: Parse> GenericAsyncReader<T, P>

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

Create a reader from its inner parts.

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

Decompose the AsyncReader into its parts

pub fn inner(&self) -> &T

Access the inner AsyncBufRead

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

Access the inner AsyncBufRead, mutably

pub fn inner_pinned(self: Pin<&mut Self>) -> Pin<&mut T>

Access the inner AsyncBufRead, mutably and pinned.

pub fn parser(&self) -> &P

Access the parser

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

Access the parser, mutably

pub fn parser_pinned(self: Pin<&mut Self>) -> &mut P

Access the inner parser, mutably and while pinned.

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

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

Attempts to parse a single event from the source.

If the EOF has been reached with a valid document, None is returned.

I/O errors may be retried, all other errors are fatal (and will be returned again by the parser on the next invocation without reading further data from the source).

In most cases, it is advisable to use read instead.

impl<T: AsyncBufRead + Unpin, P: Parse> GenericAsyncReader<T, P>

pub fn read(&mut self) -> ReadEvent<'_, T, P>

Read a single event from the parser.

End-of-file handling

If poll_fill_buf() returns an empty buffer, it is treated as the end of file. At end of file, either the return value None is produced or an error.

I/O error handling

Any I/O error is passed back to the caller. This allows any I/O error to be retried (though the success of that will obviously depend on the backing reader).

Parser error handling

Errors returned by the parser are fatal and are returned as InvalidData io::Error error values.

Equivalent to:

async fn read(&mut self) -> Result<Option<Event>>;

pub fn read_all<F>(&mut self, cb: F) -> ReadAll<'_, T, P, F>

Read all events which can be produced from the data source (at this point in time).

The given cb is invoked for each event.

End-of-file handling

If poll_fill_buf() returns an empty buffer, it is treated as the end of file. At end of file the function returns (either successfully or with an error).

I/O error handling

Any I/O error is passed back to the caller. This allows any I/O error to be retried (though the success of that will obviously depend on the backing reader).

Parser error handling

Errors returned by the parser are fatal and are returned as InvalidData io::Error error values.

Equivalent to:

    async fn read_all<F>(&mut self, mut cb: F) -> Result<()>
           where F: FnMut(Event) -> () + Send

Trait Implementations

impl<T: AsyncBufRead, P: Parse> Stream for GenericAsyncReader<T, P>

Available on crate feature stream only.

type Item = Result<<P as Parse>::Output, Error>

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 GenericAsyncReader<T, P>

where __Origin<'__pin, T, P>: Unpin,