Enum PropertyPath 

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

A SPARQL 1.1 property path expression.

Variants

Iri(String)

A simple IRI predicate: foaf:knows

Sequence(Box<PropertyPath>, Box<PropertyPath>)

Sequence path: a / b (a then b)

Alternative(Box<PropertyPath>, Box<PropertyPath>)

Alternative path: a | b (a or b)

ZeroOrMore(Box<PropertyPath>)

Zero or more: a*

OneOrMore(Box<PropertyPath>)

One or more: a+

ZeroOrOne(Box<PropertyPath>)

Zero or one: a?

Inverse(Box<PropertyPath>)

Inverse path: ^a (reverse direction)

Implementations

impl PropertyPath

pub fn iri(s: impl Into<String>) -> Self

Create a simple IRI property path.

pub fn seq(a: PropertyPath, b: PropertyPath) -> Self

Create a sequence path: a / b.

pub fn alt(a: PropertyPath, b: PropertyPath) -> Self

Create an alternative path: a | b.

pub fn zero_or_more(p: PropertyPath) -> Self

Create a zero-or-more closure path: a*.

pub fn one_or_more(p: PropertyPath) -> Self

Create a one-or-more closure path: a+.

pub fn zero_or_one(p: PropertyPath) -> Self

Create a zero-or-one optional path: a?.

pub fn inverse(p: PropertyPath) -> Self

Create an inverse path: ^a.

pub fn depth(&self) -> usize

Nesting depth of the path expression.

pub fn contains_closure(&self) -> bool

Whether this path contains a closure operator (* or +).

pub fn is_simple(&self) -> bool

Whether this path is a simple IRI (no operators).

Trait Implementations

impl Clone for PropertyPath

fn clone(&self) -> PropertyPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PropertyPath

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PropertyPath

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PropertyPath

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

Formats the value using the given formatter.

impl PartialEq for PropertyPath

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PropertyPath