Struct XPathContext 

pub struct XPathContext<'doc> {
    pub index: DocIndex<'doc>,
    /* private fields */
}

Reusable XPath context for an arena-allocated ArenaDocument.

Build once, evaluate many times. Internally the XPath evaluator is generic over DocIndexLike.

Fields

index: DocIndex<'doc>

The flat index used by the evaluator. Exposed so external adapters (e.g. the libxml2 C-ABI shim in sup-xml-compat) can build their own result-object wrappers without rebuilding the index.

Implementations

impl<'doc> XPathContext<'doc>

pub fn new(doc: &'doc ArenaDocument) -> Self

Build a strict-mode evaluation context for doc. O(n) in the number of nodes. Equivalent to new_with with default XPathOptions.

Examples found in repository

examples/profile_xpath_slow_unit.rs (line 66)

fn main() {
    let path = std::env::args().nth(1)
        .expect("usage: profile_xpath_slow_unit <artifact-path>");
    let bytes = std::fs::read(&path).expect("read artifact");
    let full = std::str::from_utf8(&bytes).expect("artifact is UTF-8");

    let doc = parse_str(FIXTURE, &ParseOptions::default()).expect("fixture parses");
    let ctx = XPathContext::new(&doc);

    // Report the predicate-nesting depth of the original artifact so we
    // can pick a sensible MAX_PREDICATE_NESTING_DEPTH.
    use sup_xml_core::xpath::ast::max_predicate_nesting;
    use sup_xml_core::xpath::parse_xpath;
    match parse_xpath(full) {
        Ok(e)  => println!("# original artifact parses; predicate-nesting depth = {}", max_predicate_nesting(&e)),
        Err(e) => println!("# original artifact parse-error: {}",
                           e.message.chars().take(80).collect::<String>()),
    }

    println!("# best-of-3 timing of slow-unit reductions");
    println!("{:>9}  {:>8}  {}", "time", "len", "expression  →  result");
    println!("{}", "-".repeat(78));

    // ── baseline ──────────────────────────────────────────────────────────
    time_one(&ctx, "FULL artifact (1018 B)", full);

    // ── strip from the right, halving each time ──────────────────────────
    time_one(&ctx, "first 512 B",  &full[..full.len().min(512)]);
    time_one(&ctx, "first 256 B",  &full[..full.len().min(256)]);
    time_one(&ctx, "first 128 B",  &full[..full.len().min(128)]);
    time_one(&ctx, "first  64 B",  &full[..full.len().min(64)]);

    // ── isolate specific patterns ────────────────────────────────────────
    time_one(&ctx, "just nested substring chains",
        "r*substring(/*substring(/*substring(/*substring(/*substring(/*substring(/*substring(//book[author='Hu'])))))))");
    time_one(&ctx, "deep //*/*/* descent chain",
        "//*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*");
    time_one(&ctx, "nested predicates (the worst case)",
        "//*[//*[//*[//*[//*[//*[//*[.='x']]]]]]]");
    time_one(&ctx, "nested //*/* in predicate",
        "//*[/*//*//*//*//*//*//*//*//*//*]");
    time_one(&ctx, "wildcard arithmetic chain",
        "//*/*/*/* * * * * * * * * * //*/*/*");
    time_one(&ctx, "many top-level *",
        "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *");

    // ── single-step costs for comparison ─────────────────────────────────
    time_one(&ctx, "trivial root",                                 "/");
    time_one(&ctx, "trivial wildcard",                             "/*");
    time_one(&ctx, "all elements",                                 "//*");
    time_one(&ctx, "all elements with trivial predicate",          "//*[true()]");
    time_one(&ctx, "all elements with attribute access",           "//*[@id]");
    time_one(&ctx, "books filtered by author",                     "//book[author='Hunt']");
    time_one(&ctx, "substring on string literal",                  "substring('hello', 2, 3)");
    time_one(&ctx, "substring on node text",                       "substring(//title, 2, 3)");
}

pub fn new_with(doc: &'doc ArenaDocument, options: XPathOptions) -> Self

Build an evaluation context for doc with explicit options. Use this to opt into libxml2-compatible behaviour for the three spec deviations called out on XPathOptions.

pub fn eval(&self, src: &str) -> Result<XPathValue>

Examples found in repository

examples/profile_xpath_slow_unit.rs (line 47)

fn time_one(ctx: &XPathContext, label: &str, expr: &str) {
    let mut best = std::time::Duration::MAX;
    let mut last_result = String::new();
    for _ in 0..3 {
        let t = Instant::now();
        let r = ctx.eval(expr);
        let dt = t.elapsed();
        if dt < best { best = dt; }
        last_result = match &r {
            Ok(_)  => "Ok".to_string(),
            Err(e) => format!("Err: {}", e.message.chars().take(60).collect::<String>()),
        };
    }
    println!("{:>9.2?}  [{:>4} B]  {label}   →  {last_result}",
             best, expr.len());
}

pub fn eval_at(&self, src: &str, context_node: NodeId) -> Result<XPathValue>

Evaluate src against a specific context node. XPath 1.0 allows the context-node to be any node in the document; the libxml2 ABI exposes this via xmlXPathContext.node.

pub fn eval_with( &self, src: &str, context_node: NodeId, bindings: &dyn XPathBindings, ) -> Result<XPathValue>

Evaluate src against context_node, consulting bindings for user-registered functions (extensions= in lxml), variables ($varname), and namespace prefix resolution. This is the entry point the libxml2 C-ABI shim (sup-xml-compat::xpath) uses when its xmlXPathContext carries registered namespaces, functions, or variables.

pub fn id_for_element(&self, ptr: *const Node<'_>) -> Option<NodeId>

Find the index ID for a node identified by its arena pointer. Returns None if the pointer doesn’t match any indexed node. Linear scan; O(n) in document size — call once per evaluation, not per expression step.

Handles attribute pointers too: libxslt sets the XPath context node to an xmlAttr* while iterating @* (<xsl:for-each select="@*">), and the C-ABI layer hands that pointer here cast to *const Node. The match is by raw address, so comparing the indexed &Attribute against ptr is sound regardless of the nominal pointer type.

pub fn eval_bool(&self, src: &str) -> Result<bool>

pub fn eval_str(&self, src: &str) -> Result<String>

pub fn eval_num(&self, src: &str) -> Result<f64>

pub fn eval_strings(&self, src: &str) -> Result<Vec<String>>

pub fn eval_count(&self, src: &str) -> Result<usize>

pub fn eval_node_xml(&self, src: &str) -> Result<Vec<String>>

Evaluate src and return each matched node serialized as XML (the XPath equivalent of xmllint --xpath’s default output).

• Element / Text / Comment / CData / PI nodes serialize to their subtree XML form, identical to [crate::serialize_node_to_string] with default options.
• Attribute nodes render as name="value" with the value attribute-escaped.
• Namespace nodes render as xmlns:prefix="uri" (or xmlns="…" for the default namespace).
• The synthetic Document node (returned by /) serializes as the whole document via crate::serialize_to_string.

Non-NodeSet results (string / number / boolean) collapse to a single-element vec containing their XPath 1.0 string form, matching Self::eval_strings.