Enum PathExpr 

pub enum PathExpr {
    Iri(String),
    Inverse(Box<PathExpr>),
    Sequence(Box<PathExpr>, Box<PathExpr>),
    Alternative(Box<PathExpr>, Box<PathExpr>),
    ZeroOrMore(Box<PathExpr>),
    OneOrMore(Box<PathExpr>),
    ZeroOrOne(Box<PathExpr>),
    NegatedSet(Vec<String>),
}

A SPARQL property path expression.

Represents the full set of SPARQL 1.1 property path operators, enabling in-memory construction, analysis, and serialisation without requiring a triple store.

Variants

Iri(String)

A single IRI step.

Inverse(Box<PathExpr>)

Inverse path: ^p.

Sequence(Box<PathExpr>, Box<PathExpr>)

Sequence: p/q.

Alternative(Box<PathExpr>, Box<PathExpr>)

Alternative: p|q.

ZeroOrMore(Box<PathExpr>)

Zero-or-more: p*.

OneOrMore(Box<PathExpr>)

One-or-more: p+.

ZeroOrOne(Box<PathExpr>)

Zero-or-one: p?.

NegatedSet(Vec<String>)

Negated property set: !(p|q).

Implementations

impl PathExpr

pub fn iri(iri: &str) -> Self

Create a single IRI step path expression.

pub fn inverse(inner: PathExpr) -> Self

Create an inverse path expression (^p).

pub fn sequence(left: PathExpr, right: PathExpr) -> Self

Create a sequence path expression (p/q).

pub fn alternative(left: PathExpr, right: PathExpr) -> Self

Create an alternative path expression (p|q).

pub fn zero_or_more(inner: PathExpr) -> Self

Create a zero-or-more repetition path expression (p*).

pub fn one_or_more(inner: PathExpr) -> Self

Create a one-or-more repetition path expression (p+).

pub fn zero_or_one(inner: PathExpr) -> Self

Create a zero-or-one path expression (p?).

pub fn negated_set(iris: &[&str]) -> Self

Create a negated property set path expression (!(p|q|...)).

Accepts a slice of IRI strings.

pub fn depth(&self) -> usize

Returns the nesting depth / complexity of the path expression.

A single IRI or negated set has depth 1. Each wrapping operator adds 1.

pub fn iris(&self) -> Vec<String>

Returns all unique IRIs referenced in the path expression, in sorted order.

pub fn can_match_zero(&self) -> bool

Returns true if this path expression can match zero steps (i.e., is nullable).

• * and ? operators are always nullable.
• + is nullable iff its inner expression is nullable (it cannot be nullable unless inner is, but p+ itself requires ≥1 match).
• Sequences are nullable only if both arms are nullable.
• Alternatives are nullable if either arm is nullable.
• Plain IRIs and negated sets are not nullable.
• Inverse is nullable iff its inner is nullable.

pub fn to_sparql(&self) -> String

Converts the path expression to its SPARQL 1.1 string representation.

Parentheses are inserted to make operator precedence explicit.

pub fn is_simple_iri(&self) -> bool

Returns true if the path is a plain IRI step (no operators).

pub fn as_iri(&self) -> Option<&str>

Returns the IRI string if this is a simple IRI step, otherwise None.

pub fn iri_count(&self) -> usize

Counts the total number of IRI references (including duplicates) in the path.

Trait Implementations

impl Clone for PathExpr

fn clone(&self) -> PathExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PathExpr

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

Formats the value using the given formatter.

impl Display for PathExpr

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

Formats the value using the given formatter.

impl PartialEq for PathExpr

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PathExpr