[][src]Struct pest::iterators::Pair

pub struct Pair<'i, R> { /* fields omitted */ }

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<'i, R: RuleType> Pair<'i, R>[src]

pub fn as_rule(&self) -> R[src]

Returns the Rule of the Pair.

Examples

enum Rule {
    a
}

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

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

pub fn as_str(&self) -> &'i str[src]

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

Examples

enum Rule {
    ab
}

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

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

pub fn into_span(self) -> Span<'i>[src]

Deprecated since 2.0.0:

Please use as_span instead

Returns the Span defined by the Pair, consuming it.

Examples

enum Rule {
    ab
}

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

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

pub fn as_span(&self) -> Span<'i>[src]

Returns the Span defined by the Pair, without consuming it.

Examples

enum Rule {
    ab
}

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

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

Important traits for Pairs<'i, R>
pub fn into_inner(self) -> Pairs<'i, R>[src]

Returns the inner Pairs between the Pair, consuming it.

Examples

enum Rule {
    a
}

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

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

Important traits for Tokens<'i, R>
pub fn tokens(self) -> Tokens<'i, R>[src]

Returns the Tokens for the Pair.

Examples

enum Rule {
    a
}

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

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

Trait Implementations

impl<'i, R: Clone> Clone for Pair<'i, R>[src]

impl<'i, R: RuleType> Debug for Pair<'i, R>[src]

impl<'i, R: RuleType> Display for Pair<'i, R>[src]

impl<'i, R: Eq> Eq for Pair<'i, R>[src]

impl<'i, R: Hash> Hash for Pair<'i, R>[src]

impl<'i, R: PartialEq> PartialEq<Pair<'i, R>> for Pair<'i, R>[src]

Auto Trait Implementations

impl<'i, R> !RefUnwindSafe for Pair<'i, R>

impl<'i, R> !Send for Pair<'i, R>

impl<'i, R> !Sync for Pair<'i, R>

impl<'i, R> Unpin for Pair<'i, R>

impl<'i, R> UnwindSafe for Pair<'i, R> where
    R: RefUnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.