Enum ElementParser

pub enum ElementParser {
    Outside,
    SingleQ,
    DoubleQ,
}

A parser that search a > symbol in the slice outside of quoted regions.

The parser considers two quoted regions: a double-quoted ("...") and a single-quoted ('...') region. Matches found inside those regions are not considered as results. Each region starts and ends by its quote symbol, which cannot be escaped (but can be encoded as XML character entity or named entity. Anyway, that encoding does not contain literal quotes).

To use a parser create an instance of parser and feed data into it. After successful search the parser will return Some with position of found symbol. If search is unsuccessful, a None will be returned. You typically would expect positive result of search, so that you should feed new data until you get it.

NOTE: after successful match the parser does not returned to the initial state and should not be used anymore. Create a new parser if you want to perform new search.

Example

use quick_xml::parser::{ElementParser, Parser};

let mut parser = ElementParser::default();

// Parse `<my-element  with = 'some > inside'>and the text follow...`
// splitted into three chunks
assert_eq!(parser.feed(b"<my-element"), None);
// ...get new chunk of data
assert_eq!(parser.feed(b" with = 'some >"), None);
// ...get another chunk of data
assert_eq!(parser.feed(b" inside'>and the text follow..."), Some(8));
//                       ^       ^
//                       0       8

Variants

Outside

The initial state (inside element, but outside of attribute value).

SingleQ

Inside a single-quoted region ('...').

DoubleQ

Inside a double-quoted region ("...").

Trait Implementations

impl Clone for ElementParser

fn clone(&self) -> ElementParser

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ElementParser

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

Formats the value using the given formatter.

impl Default for ElementParser

fn default() -> Self

Returns the “default value” for a type.

impl Parser for ElementParser

fn feed(&mut self, bytes: &[u8]) -> Option<usize>

Returns number of consumed bytes or None if > was not found in bytes.

fn eof_error() -> SyntaxError

Returns parse error produced by this parser in case of reaching end of input without finding the end of a parsed thing.

impl PartialEq for ElementParser

fn eq(&self, other: &ElementParser) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ElementParser

impl Eq for ElementParser

impl StructuralPartialEq for ElementParser