pub struct Pair<'i, R> { /* private fields */ }
Expand description
A matching pair of Token
s 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 Token
s between them can form such pairs as well.
This is similar to the brace matching problem in
editors.
Implementations§
Source§impl<'i, R: RuleType> Pair<'i, R>
impl<'i, R: RuleType> Pair<'i, R>
Sourcepub fn as_rule(&self) -> R
pub fn as_rule(&self) -> R
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);
Sourcepub fn as_str(&self) -> &'i str
pub fn as_str(&self) -> &'i str
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");
Sourcepub fn get_input(&self) -> &'i str
pub fn get_input(&self) -> &'i str
Returns the input string of the Pair
.
This function returns the input string of the Pair
as a &str
. This is the source string
from which the Pair
was created. The returned &str
can be used to examine the contents of
the Pair
or to perform further processing on the string.
§Examples
enum Rule {
ab
}
// Example: Get input string from a Pair
let input = "ab";
let pair = pest::state(input, |state| {
// generating Token pair with Rule::ab ...
}).unwrap().next().unwrap();
assert_eq!(pair.as_str(), "ab");
assert_eq!(input, pair.get_input());
Sourcepub fn into_span(self) -> Span<'i>
👎Deprecated since 2.0.0: Please use as_span
instead
pub fn into_span(self) -> Span<'i>
as_span
insteadReturns 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");
Sourcepub fn as_span(&self) -> Span<'i>
pub fn as_span(&self) -> Span<'i>
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");
Sourcepub fn as_node_tag(&self) -> Option<&str>
pub fn as_node_tag(&self) -> Option<&str>
Get current node tag
Sourcepub fn into_inner(self) -> Pairs<'i, R> ⓘ
pub fn into_inner(self) -> Pairs<'i, R> ⓘ
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());
Sourcepub fn tokens(self) -> Tokens<'i, R> ⓘ
pub fn tokens(self) -> Tokens<'i, R> ⓘ
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: Eq> Eq for Pair<'i, R>
Auto Trait Implementations§
impl<'i, R> Freeze for Pair<'i, R>
impl<'i, R> RefUnwindSafe for Pair<'i, R>where
R: RefUnwindSafe,
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§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
Source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)