Enum SHACLPath 

pub enum SHACLPath {
    Predicate {
        pred: IriS,
    },
    Alternative {
        paths: Vec<SHACLPath>,
    },
    Sequence {
        paths: Vec<SHACLPath>,
    },
    Inverse {
        path: Box<SHACLPath>,
    },
    ZeroOrMore {
        path: Box<SHACLPath>,
    },
    OneOrMore {
        path: Box<SHACLPath>,
    },
    ZeroOrOne {
        path: Box<SHACLPath>,
    },
}

Represents a SHACL property path for navigating RDF graphs.

SHACL paths follow the SHACL property paths spec which are a subset of SPARQL property paths. They enable complex navigation patterns through RDF graphs, extending simple predicate-based traversal with operations like sequences, alternatives, inverses, and quantifiers.

Variants

Predicate

A direct predicate path using a single IRI.

Fields

pred: IriS

Alternative

An alternative path representing a union of multiple paths.

Fields

paths: Vec<SHACLPath>

Sequence

A sequence path representing composed navigation.

Fields

paths: Vec<SHACLPath>

Inverse

An inverse path representing reverse property navigation.

Fields

path: Box<SHACLPath>

ZeroOrMore

A zero-or-more quantified path (transitive closure).

Fields

path: Box<SHACLPath>

OneOrMore

A one-or-more quantified path (non-empty transitive closure).

Fields

path: Box<SHACLPath>

ZeroOrOne

A zero-or-one quantified path (optional path).

Fields

path: Box<SHACLPath>

Implementations

impl SHACLPath

pub fn iri(pred: IriS) -> Self

Creates a simple predicate path from an IRI.

This is a convenience constructor for the most common path type, equivalent to SHACLPath::Predicate { pred }.

Arguments

• pred - The IRI representing the predicate to navigate

pub fn pred(&self) -> Option<&IriS>

Extracts the predicate IRI from a simple predicate path.

pub fn sequence(paths: Vec<SHACLPath>) -> Self

Creates a sequence path from multiple paths.

Arguments

• paths - A vector of paths to compose in sequence

pub fn alternative(paths: Vec<SHACLPath>) -> Self

Creates an alternative path from multiple paths.

Arguments

• paths - A vector of alternative paths

pub fn inverse(path: SHACLPath) -> Self

Creates an inverse path that navigates backwards.

Arguments

• path - The path to invert

pub fn zero_or_more(path: SHACLPath) -> Self

Creates a zero-or-more quantified path (transitive closure).

Arguments

• path - The path to repeat

pub fn one_or_more(path: SHACLPath) -> Self

Creates a one-or-more quantified path (non-empty transitive closure).

Arguments

• path - The path to repeat

pub fn zero_or_one(path: SHACLPath) -> Self

Creates a zero-or-one quantified path (optional path).

Arguments

• path - The optional path

Trait Implementations

impl Clone for SHACLPath

fn clone(&self) -> SHACLPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SHACLPath

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

Formats the value using the given formatter.

impl Display for SHACLPath

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

Formats the SHACL path as a SPARQL-like property path expression.

The output follows SPARQL property path syntax conventions:

• Predicates are displayed as IRIs
• Alternatives use | separator with parentheses
• Sequences use / separator with parentheses
• Inverses use ^ prefix with parentheses
• Quantifiers use postfix operators: *, +, ?

impl Hash for SHACLPath

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SHACLPath

fn eq(&self, other: &SHACLPath) -> 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 Serialize for SHACLPath

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SHACLPath

impl StructuralPartialEq for SHACLPath