Struct rec::Tokens

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

Stores the found capture groups.

Methods

impl<'_> Tokens<'_>

pub fn name_str(&self, name: &str) -> Option<&str>

Returns the str of the Match for the given capture name.

If no match is found, returns None.

Methods from Deref<Target = Captures<'t>>

pub fn get(&self, i: usize) -> Option<Match<'t>>

Returns the match associated with the capture group at index i. If i does not correspond to a capture group, or if the capture group did not participate in the match, then None is returned.

Examples

Get the text of the match with a default of an empty string if this group didn't participate in the match:

let re = Regex::new(r"[a-z]+(?:([0-9]+)|([A-Z]+))").unwrap();
let caps = re.captures("abc123").unwrap();

let text1 = caps.get(1).map_or("", |m| m.as_str());
let text2 = caps.get(2).map_or("", |m| m.as_str());
assert_eq!(text1, "123");
assert_eq!(text2, "");

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

Returns the match for the capture group named name. If name isn't a valid capture group or didn't match anything, then None is returned.

pub fn iter(&'c self) -> SubCaptureMatches<'c, 't>

An iterator that yields all capturing matches in the order in which they appear in the regex. If a particular capture group didn't participate in the match, then None is yielded for that capture.

The first match always corresponds to the overall match of the regex.

pub fn expand(&self, replacement: &str, dst: &mut String)

Expands all instances of $name in replacement to the corresponding capture group name, and writes them to the dst buffer given.

name may be an integer corresponding to the index of the capture group (counted by order of opening parenthesis where 0 is the entire match) or it can be a name (consisting of letters, digits or underscores) corresponding to a named capture group.

If name isn't a valid capture group (whether the name doesn't exist or isn't a valid index), then it is replaced with the empty string.

The longest possible name is used. e.g., $1a looks up the capture group named 1a and not the capture group at index 1. To exert more precise control over the name, use braces, e.g., ${1}a.

To write a literal $ use $$.

pub fn len(&self) -> usize

Returns the number of captured groups.

This is always at least 1, since every regex has at least one capture group that corresponds to the full match.

Trait Implementations

impl<'t> Deref for Tokens<'t>

type Target = Captures<'t>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'t> Debug for Tokens<'t>

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

Formats the value using the given formatter.