Enum Rbe

pub enum Rbe<K, V, R>
where
    K: Key,
    V: Value,
    R: Ref,
{
    Fail {
        error: RbeError<K, V, R>,
    },
    Empty,
    Symbol {
        key: K,
        cond: MatchCond<K, V, R>,
        card: Cardinality,
    },
    And {
        exprs: Vec<Rbe<K, V, R>>,
    },
    Or {
        exprs: Vec<Rbe<K, V, R>>,
    },
    Star {
        expr: Box<Rbe<K, V, R>>,
    },
    Plus {
        expr: Box<Rbe<K, V, R>>,
    },
    Repeat {
        expr: Box<Rbe<K, V, R>>,
        card: Cardinality,
    },
}

Variants

Fail

Fields

error: RbeError<K, V, R>

Empty

Symbol

Fields

key: K

cond: MatchCond<K, V, R>

card: Cardinality

And

Fields

exprs: Vec<Rbe<K, V, R>>

Or

Fields

exprs: Vec<Rbe<K, V, R>>

Star

Fields

expr: Box<Rbe<K, V, R>>

Plus

Fields

expr: Box<Rbe<K, V, R>>

Repeat

Fields

expr: Box<Rbe<K, V, R>>

card: Cardinality

Implementations

impl<K, V, R> Rbe<K, V, R>

where K: Key, V: Value, R: Ref,

pub fn empty() -> Rbe<K, V, R>

pub fn symbol(key: K, min: usize, max: Max) -> Rbe<K, V, R>

pub fn symbol_cond( key: K, cond: MatchCond<K, V, R>, min: Min, max: Max, ) -> Rbe<K, V, R>

pub fn or<I>(exprs: I) -> Rbe<K, V, R>

where I: IntoIterator<Item = Rbe<K, V, R>>,

pub fn and<I>(exprs: I) -> Rbe<K, V, R>

where I: IntoIterator<Item = Rbe<K, V, R>>,

pub fn opt(v: Rbe<K, V, R>) -> Rbe<K, V, R>

pub fn plus(expr: Rbe<K, V, R>) -> Rbe<K, V, R>

pub fn star(expr: Rbe<K, V, R>) -> Rbe<K, V, R>

pub fn repeat(expr: Rbe<K, V, R>, min: usize, max: Max) -> Rbe<K, V, R>

pub fn is_fail(&self) -> bool

pub fn symbols(&self) -> HashSet<K>

pub fn nullable(&self) -> bool

pub fn deriv( &self, symbol: &K, value: &V, n: usize, open: bool, controlled: &HashSet<K>, pending: &mut Pending<V, R>, ) -> Rbe<K, V, R>

where K: Eq + Hash + Clone,

Calculates the derivative of a rbe for a symbol with value open indicates if we allow extra symbols controlled contains the list of symbols controlled by the rbe that should not be assumed as extra symbols pending

Trait Implementations

impl<K, V, R> Clone for Rbe<K, V, R>

where K: Key + Clone, V: Value + Clone, R: Ref + Clone,

fn clone(&self) -> Rbe<K, V, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V, R> Debug for Rbe<K, V, R>

where K: Key, V: Value, R: Ref,

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

Formats the value using the given formatter.

impl<K, V, R> Default for Rbe<K, V, R>

where K: Key, V: Value, R: Ref,

fn default() -> Rbe<K, V, R>

Returns the “default value” for a type.

impl<'de, K, V, R> Deserialize<'de> for Rbe<K, V, R>

where K: Key + Deserialize<'de>, V: Value + Deserialize<'de>, R: Ref + Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V, R> Display for Rbe<K, V, R>

where K: Key, V: Value, R: Ref,

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

Formats the value using the given formatter.

impl<K, V, R> PartialEq for Rbe<K, V, R>

where K: Key + PartialEq, V: Value + PartialEq, R: Ref + PartialEq,

fn eq(&self, other: &Rbe<K, V, R>) -> 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<K, V, R> Serialize for Rbe<K, V, R>

where K: Key + Serialize, V: Value + Serialize, R: Ref + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, R> Eq for Rbe<K, V, R>

where K: Key + Eq, V: Value + Eq, R: Ref + Eq,

impl<K, V, R> StructuralPartialEq for Rbe<K, V, R>

where K: Key, V: Value, R: Ref,