Struct HtmlSaxParser 

pub struct HtmlSaxParser<H>
where
    H: HtmlSaxHandler + 'static,
{ /* private fields */ }

Push-based HTML parser. Caller drives input chunks via feed; the parser dispatches events synchronously into the registered handler as they’re produced.

libxml2 htmlCreatePushParserCtxt + htmlParseChunk analogue, or lxml’s HTMLParser(target=…) + parser.feed(bytes).

Example

use sup_xml_core::html::{HtmlAttrs, HtmlSaxHandler, HtmlSaxParser};

#[derive(Default)]
struct LinkCollector {
    hrefs: Vec<String>,
}

impl HtmlSaxHandler for LinkCollector {
    fn start_element(&mut self, name: &str, attrs: HtmlAttrs<'_>) {
        if name == "a" {
            if let Some(href) = attrs.get("href") {
                self.hrefs.push(href.to_string());
            }
        }
    }
}

let html = r#"<a href="/x">x</a><a href="/y">y</a>"#;
let mut p = HtmlSaxParser::new(LinkCollector::default());
p.feed(html).unwrap();
let collector = p.finish().unwrap();
assert_eq!(collector.hrefs, vec!["/x", "/y"]);

Implementations

impl<H> HtmlSaxParser<H>

where H: HtmlSaxHandler + 'static,

pub fn new(handler: H) -> HtmlSaxParser<H>

Create a push parser with default options.

pub fn with_opts(handler: H, opts: HtmlParseOptions) -> HtmlSaxParser<H>

Create a push parser with explicit options.

pub fn feed(&mut self, chunk: &str) -> Result<(), XmlError>

Feed a chunk of UTF-8 text. Drives the tokenizer and dispatches any emitted events synchronously into the handler before returning.

Errors only when an internal limit (e.g. max_text_bytes) is exceeded.

pub fn finish(self) -> Result<H, XmlError>

Signal end-of-input. Flushes any pending text, dispatches EndElement events for any still-open elements, then calls end_document. Returns the handler.