Struct pest::iterators::Pair

pub struct Pair<R, I: Input> { /* fields omitted */ }

A struct containing a matching pair of Tokens and everything between them.

A matching Token pair is formed by a Token::Start and a subsequent Token::End with the same Rule, with the condition that all Tokens between them can form such pairs as well. This is similar to the brace matching problem in editors.

Methods

impl<R: RuleType, I: Input> Pair<R, I>

fn as_rule(&self) -> R

Returns the Rule of the Pair.

Examples

enum Rule {
    a
}

let input = Rc::new(StringInput::new("".to_owned()));
let pair = pest::state(input, |state, pos| {
    // generating Token pair with Rule::a ...
}).unwrap().next().unwrap();

assert_eq!(pair.as_rule(), Rule::a);

fn as_str(&self) -> &str

Captures a &str slice from the Input defined by the token Pair.

Examples

enum Rule {
    ab
}

let input = Rc::new(StringInput::new("ab".to_owned()));
let pair = pest::state(input, |state, pos| {
    // generating Token pair with Rule::ab ...
}).unwrap().next().unwrap();

assert_eq!(pair.as_str(), "ab");

fn into_span(self) -> Span<I>

Returns the Span defined by the Pair, consuming it.

Examples

enum Rule {
    ab
}

let input = Rc::new(StringInput::new("ab".to_owned()));
let pair = pest::state(input, |state, pos| {
    // generating Token pair with Rule::ab ...
}).unwrap().next().unwrap();

assert_eq!(pair.into_span().as_str(), "ab");

fn into_inner(self) -> Pairs<R, I>

Returns the inner Pairs between the Pair, consuming it.

Examples

enum Rule {
    a
}

let input = Rc::new(StringInput::new("".to_owned()));
let pair = pest::state(input, |state, pos| {
    // generating Token pair with Rule::a ...
}).unwrap().next().unwrap();

assert!(pair.into_inner().next().is_none());

fn tokens(self) -> TokenIterator<R, I>

Converts the Pair into a TokenIterator.

Examples

enum Rule {
    a
}

let input = Rc::new(StringInput::new("".to_owned()));
let pair = pest::state(input, |state, pos| {
    // generating Token pair with Rule::a ...
}).unwrap().next().unwrap();
let tokens: Vec<_> = pair.tokens().collect();

assert_eq!(tokens.len(), 2);

Trait Implementations

impl<R: Clone, I: Clone + Input> Clone for Pair<R, I>

fn clone(&self) -> Pair<R, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: RuleType, I: Input> Debug for Pair<R, I>

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

Formats the value using the given formatter.

impl<R: RuleType, I: Input> Display for Pair<R, I>

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

Formats the value using the given formatter.

impl<R: PartialEq, I: Input> PartialEq for Pair<R, I>

fn eq(&self, other: &Pair<R, I>) -> 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 !=.

impl<R: Eq, I: Input> Eq for Pair<R, I>

impl<R: Hash, I: Input> Hash for Pair<R, I>

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, 

Feeds a slice of this type into the given [Hasher].