Struct regress::Regex

pub struct Regex { /* fields omitted */ }

A Regex is the compiled version of a pattern.

Implementations

impl Regex

pub fn new(pattern: &str) -> Result<Regex, Error>

Construct a regex by parsing pattern using the default flags. An Error may be returned if the syntax is invalid. Note that this is rather expensive; prefer to cache a Regex which is intended to be used more than once.

pub fn with_flags<F>(pattern: &str, flags: F) -> Result<Regex, Error> where
    F: Into<Flags>, 

Construct a regex by parsing pattern with flags. An Error may be returned if the syntax is invalid. Note it is preferable to cache a Regex which is intended to be used more than once, as the parse may be expensive. For example:

pub fn find(&self, text: &str) -> Option<Match>

Searches text to find the first match.

pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> Matches<'r, 't>

Searches text, returning an iterator over non-overlapping matches. Note that the resulting Iterator borrows both the regex 'r and the input string as 't.

pub fn find_from<'r, 't>(
    &'r self,
    text: &'t str,
    start: usize
) -> Matches<'r, 't>

Returns an iterator for matches found in ‘text’ starting at byte index start. Note this may be different from passing a sliced text in the case of lookbehind assertions. Example:

 use regress::Regex;
 let text = "xyxy";
 let re = Regex::new(r"(?<=x)y").unwrap();
 let t1 = re.find(&text[1..]).unwrap().range();
 assert!(t1 == (2..3));
 let t2 = re.find_from(text, 1).next().unwrap().range();
 assert!(t2 == (1..2));

pub fn find_ascii(&self, text: &str) -> Option<Match>

Searches text to find the first match. The input text is expected to be ascii-only: only ASCII case-folding is supported.

pub fn find_iter_ascii<'r, 't>(&'r self, text: &'t str) -> AsciiMatches<'r, 't>

Searches text, returning an iterator over non-overlapping matches. The input text is expected to be ascii-only: only ASCII case-folding is supported.

pub fn find_from_ascii<'r, 't>(
    &'r self,
    text: &'t str,
    start: usize
) -> AsciiMatches<'r, 't>

Returns an iterator for matches found in ‘text’ starting at byte index start.

Trait Implementations

impl Clone for Regex

fn clone(&self) -> Regex

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Regex

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

Formats the value using the given formatter.

impl FromStr for Regex

fn from_str(s: &str) -> Result<Self, Error>

Attempts to parse a string into a regular expression

type Err = Error

The associated error which can be returned from parsing.