Struct XmlParser 

pub struct XmlParser<'a> {
    pub input: &'a str,
    pub offset: usize,
}

Hand-rolled recursive-descent parser for XML and basic HTML documents.

Produces an XmlTree where every node’s offset field is the exact byte position of the opening < (elements) or first character (text nodes) in input. This byte-accuracy is required when reading positions are persisted across sessions.

The parser is intentionally lenient: unknown tags, processing instructions, and CDATA sections are skipped silently. Self-closing tags (<br/>, <img/>) are supported.

Fields

input: &'a str

The full source string being parsed.

offset: usize

Current byte offset into input.

Implementations

impl<'a> XmlParser<'a>

pub fn new(input: &str) -> XmlParser<'_>

Creates a new parser positioned at the start of input.

fn eof(&self) -> bool

Returns true when the cursor has reached the end of the input.

fn next(&self) -> Option<char>

Returns the next character without advancing the cursor.

fn starts_with(&self, s: &str) -> bool

Returns true if the remaining input starts with s.

fn advance(&mut self, n: usize)

Advances the cursor by exactly n Unicode scalar values.

fn advance_while<F>(&mut self, test: F)

where F: FnMut(&char) -> bool,

Advances the cursor as long as test returns true for the next char.

fn advance_until(&mut self, target: &str)

Advances the cursor until target is found and consumes it. Does nothing if target is never found before EOF.

fn parse_attributes(&mut self) -> Attributes

Parses the attribute list of an open tag, stopping at > or /.

Both single- and double-quoted attribute values are supported. The cursor is left immediately before the closing > or /.

fn parse_element(&mut self, tree: &mut XmlTree, parent_id: NodeId)

Parses a single element (tag name + attributes + children) and appends it to parent_id in tree.

The cursor must be positioned immediately after the opening < when this function is called. After returning the cursor is positioned after the element’s closing tag.

fn parse_nodes(&mut self, tree: &mut XmlTree, parent_id: NodeId)

Parses all child nodes of parent_id until a matching closing tag or EOF is reached.

Handles text nodes, whitespace, elements, processing instructions (<?…?>), comments (<!--…-->), CDATA sections (<![…]]>), and DOCTYPE declarations.

pub fn parse(&mut self) -> XmlTree

Parses self.input and returns the resulting XmlTree.

Every node’s offset is the byte position of its opening < or first text character within the original source string.

Trait Implementations

impl<'a> Debug for XmlParser<'a>

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

Formats the value using the given formatter.