Struct pidgin::Match

pub struct Match<'t> { /* private fields */ }

This is a node in a parse tree. It is functionally similar to regex::Match, in fact providing much the same API, but unlike a regex::Match a pidgin::Match always corresponds to some rule, it knows what rule it corresponds to, and it records any sub-matches involved in its parsing.

The lifetime parameter 't represents the lifetime of the &str matched against.

Implementations

impl<'t> Match<'t>

pub fn as_str(&self) -> &'t str

Returns the matched text.

pub fn start(&self) -> usize

Returns the starting offset of the match.

pub fn end(&self) -> usize

Returns the ending offset of the match.

pub fn rule(&self) -> &str

Returns the grammar rule matched.

pub fn children(&self) -> Option<&[Match<'t>]>

Returns the sub-matches of this match, if any.

pub fn name(&self, name: &str) -> Option<&Match<'_>>

Returns the first Match defined by the given rule under this parse node searching recursively, depth-first, left-to-right.

pub fn all_names(&self, name: &str) -> Vec<&Match<'_>>

Returns all Matches matching the given rule in the parse tree under this node. Matches are ordered as found by a depth-first left-to-right search of the parse tree.

pub fn has(&self, name: &str) -> bool

Returns whether the given rule matched for any node in the parse tree.

Examples

let mut p = Pidgin::new();
let g = p.grammar(&vec!["cat", "dog", "camel"]);
p.rule("animal", &g);
let g = p.grammar(&vec!["carpet", "crate", "cartoon"]);
p.rule("thing", &g);
let m = p.grammar(&vec!["animal", "thing"]).matcher()?;
assert!(m.parse("cat").unwrap().has("animal"));

Trait Implementations

impl<'t> Clone for Match<'t>

fn clone(&self) -> Match<'t>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'t> Debug for Match<'t>

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

Formats the value using the given formatter.

impl<'t> Display for Match<'t>

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

Formats the value using the given formatter.

impl<'t> Ord for Match<'t>

fn cmp(&self, other: &Match<'t>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<'t> PartialEq<Match<'t>> for Match<'t>

fn eq(&self, other: &Match<'t>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'t> PartialOrd<Match<'t>> for Match<'t>

fn partial_cmp(&self, other: &Match<'t>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'t> Eq for Match<'t>