Struct rxml::RawParser

pub struct RawParser { /* private fields */ }

Low-level restricted XML 1.0 parser (without namespace support)

This parser emits RawEvent items, which represent the logical structure of the XML document before resolution of namespaces. If you want to use namespaces and have them resolved fully, use Parser instead.

Caveats

It is possible for an XML document to pass parsing using just this parser and still be not well-formed or namespace-well-formed. In particular, the following cases are not detected and must be handled by consumer code:

• Duplicate attributes
• Uses of undeclared prefixes
• Multiple attributes resolving to the same namespace URI / localpart pair after prefix expansion

See Parser for a full parser implementation which ensures well-formedness and namespace-well-formedness.

Example

use rxml::{RawParser, Parse, Error, RawEvent, XmlVersion};
use std::io;
let doc = b"<?xml version='1.0'?><hello>World!</hello>";
let mut fp = RawParser::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(), RawEvent::XmlDeclaration(_, XmlVersion::V1_0)));

Implementations

impl RawParser

pub fn new() -> Self

Create a new parser

Trait Implementations

impl Debug for RawParser

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

Formats the value using the given formatter.

impl Default for RawParser

fn default() -> Self

Returns the “default value” for a type.

impl Parse for RawParser

type Output = RawEvent

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

fn parse(&mut self, r: &mut &[u8], 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<F: FnMut(Self::Output)>( &mut self, data: &mut &[u8], at_eof: bool, f: F, ) -> Result<()>

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

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

Parse a bytes::Buf.

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

Parse a bytes::Buf completely.

impl WithOptions for RawParser

fn with_options(options: Options) -> Self

Create a new instance using the given options.