Struct regress::Regex

pub struct Regex { /* private fields */ }

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 from_unicode<I, F>(pattern: I, flags: F) -> Result<Regex, Error>

where I: Iterator<Item = u32> + Clone, F: Into<Flags>,

Construct a regex by parsing pattern with flags, where pattern is an iterator of u32 Unicode codepoints. An Error may be returned if the syntax is invalid. This allows parsing regular expressions from exotic strings in other encodings, such as UTF-16 or UTF-32.

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.