Struct rxml::Parser

pub struct Parser { /* private fields */ }

Non-blocking restricted XML 1.0 parser

The Parser allows parsing XML documents as they arrive in the application, giving back control to the caller immediately when not enough data is available for processing. This is especially useful when streaming data from sockets.

To read events from the Parser after feeding data, use its Parse trait.

Example

use rxml::{Parser, Parse, Error, ResolvedEvent, XmlVersion};
use std::io;
let doc = b"<?xml version='1.0'?><hello>World!</hello>";
let mut fp = Parser::new();
// We expect a WouldBlock, because the XML declaration is not complete yet
assert!(matches!(
	fp.parse(&mut &doc[..10], false).err().unwrap(),
	Error::IO(e) if e.kind() == io::ErrorKind::WouldBlock
));

// Now we pass the XML declaration (and some), so we expect a corresponding
// event
let ev = fp.parse(&mut &doc[10..25], false);
assert!(matches!(ev.unwrap().unwrap(), ResolvedEvent::XmlDeclaration(_, XmlVersion::V1_0)));

In contrast to a RawParser, the Parser enforces well-formedness and namespace-well-formedness.

Implementations

impl Parser

pub fn new() -> Self

Create a new parser with default settings.

Trait Implementations

impl Default for Parser

fn default() -> Self

Returns the “default value” for a type.

impl Parse for Parser

type Output = ResolvedEvent

The type of XML event which is emitted by the parser.

fn parse<T: Buf>( &mut self, r: &mut T, at_eof: bool, ) -> Result<Option<Self::Output>>

Parse a single event from the bytes in buf.

fn release_temporaries(&mut self)

Release all temporary buffers or other ephemeral allocations

fn parse_all<T: Buf, F: FnMut(Self::Output)>( &mut self, data: &mut T, at_eof: bool, f: F, ) -> Result<()>

Parse all data from the given buffer and pass the generated events to a callback.

impl WithOptions for Parser

fn with_options(options: Options) -> Self

Create a new instance using the given options.