Enum RegularPathExpr 

pub enum RegularPathExpr {
    Label(String),
    Concat(Box<RegularPathExpr>, Box<RegularPathExpr>),
    Alternation(Box<RegularPathExpr>, Box<RegularPathExpr>),
    KleeneStar(Box<RegularPathExpr>),
    Bounded {
        inner: Box<RegularPathExpr>,
        min: u32,
        max: u32,
    },
}

Regular path expression.

Variants

Label(String)

A single edge label.

Concat(Box<RegularPathExpr>, Box<RegularPathExpr>)

lhs / rhs.

Alternation(Box<RegularPathExpr>, Box<RegularPathExpr>)

lhs | rhs.

KleeneStar(Box<RegularPathExpr>)

inner *.

Bounded

inner { min, max }.

Fields

inner: Box<RegularPathExpr>

min: u32

max: u32

Implementations

impl RegularPathExpr

pub fn label(name: impl Into<String>) -> Self

pub fn concat(left: Self, right: Self) -> Self

pub fn alt(left: Self, right: Self) -> Self

pub fn star(inner: Self) -> Self

pub fn bounded(inner: Self, min: u32, max: u32) -> Self

Trait Implementations

impl Clone for RegularPathExpr

fn clone(&self) -> RegularPathExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RegularPathExpr

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

Formats the value using the given formatter.

impl Eq for RegularPathExpr

impl Hash for RegularPathExpr

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 RegularPathExpr

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RegularPathExpr