Struct pidgin::Match

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

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.

Methods

impl<'t> Match<'t>

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

Returns the matched text.

Examples

let m = grammar!{
	foo => ("bar")
}.matcher()?.parse("   bar   ").unwrap();

assert_eq!("bar", m.as_str());

pub fn start(&self) -> usize

Returns the starting offset of the match.

Examples

let m = grammar!{
	foo => ("bar")
}.matcher()?.parse("   bar   ").unwrap();

assert_eq!(3, m.start());

pub fn end(&self) -> usize

Returns the ending offset of the match.

Examples

let m = grammar!{
	foo => ("bar")
}.matcher()?.parse("   bar   ").unwrap();

assert_eq!(6, m.end());

pub fn rule(&self) -> &str

Returns the grammar rule matched.

Examples

let m = grammar!{
	foo => ("bar")
}.matcher()?.parse("   bar   ").unwrap();

assert_eq!("foo", m.rule());

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

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

Examples

let m = grammar!{
	TOP -> <foo> <bar> <baz>
	foo => (1)
	bar => (2)
	baz => (3)
}.matcher()?.parse(" 1  2  3 ").unwrap();

let children = m.children().unwrap();

assert_eq!(3, children.len());
assert_eq!("1", children[0].as_str());
assert_eq!("foo", children[0].rule());
assert_eq!("2", children[1].as_str());
assert_eq!("bar", children[1].rule());
assert_eq!("3", children[2].as_str());
assert_eq!("baz", children[2].rule());

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.

Examples

let matcher = grammar!{
	TOP -> <foo> <bar>
	foo -> (1) <baz>
	bar -> (2) <baz>
	baz -> [["prawn", "shrimp", "crevette"]]
}.matcher()?;

let p = matcher.parse("1 crevette 2 shrimp").unwrap();
let baz = p.name("baz").unwrap();

assert_eq!("crevette", baz.as_str());

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.

Examples

let matcher = grammar!{
	TOP -> <foo> <bar>
	foo -> (1) <baz>
	bar -> (2) <baz>
	baz -> [["prawn", "shrimp", "crevette"]]
}.matcher()?;

let p = matcher.parse("1 crevette 2 shrimp").unwrap();
let names = p.all_names("baz");

assert_eq!("crevette", names[0].as_str());
assert_eq!("shrimp", names[1].as_str());

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

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

Examples

let g = grammar!{
    TOP => <animal> | <thing>
    animal => [["cat", "dog", "camel"]]
    thing  => [["carpet", "crate", "cartoon"]]
};

let m = g.matcher()?;

assert!(m.parse("cat").unwrap().has("animal"));

Trait Implementations

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

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> 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.

#[must_use] fn lt(&self, other: &Rhs) -> bool

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

#[must_use] fn le(&self, other: &Rhs) -> bool

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

#[must_use] fn gt(&self, other: &Rhs) -> bool

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

#[must_use] 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> 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) -> Self

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

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 ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.