Struct Regex 

pub struct Regex { /* private fields */ }

Main Regex struct

Holds a regular expression

Implementations

impl Regex

pub fn compile(src: &str) -> Result<Self, RegexError>

Compile the given string into a Regex

Returns error if the regex is invalid and fails to compile

Errors

If the regex fails to compile, the error variant contains a message explaining the issue

Examples found in repository

examples/example.rs (line 14)

fn main() {
    /* let rule = "^(abc|cba)$"; */
    /* let r = Regex::compile(rule).unwrap(); */

    /* println!("{rule} : {r}"); */

    /* for st in ["abc", "cba", ".abc", ".cba", ".cga"] { */
    /*     println!("{st} => {}", */
    /*         r.test(st)); */
    /* } */

    let regex = Regex::compile(".*b").unwrap();
    for m in regex.find_matches("aaaaaabaaaaaab") {
        println!("{m:#?}");
    }
}

pub fn find_matches<'a>(&'a self, src: &'a str) -> RegexMatcher<'a>

Returns an Iterator over all the matches of the Regex in the given string

Examples found in repository

examples/example.rs (line 15)

fn main() {
    /* let rule = "^(abc|cba)$"; */
    /* let r = Regex::compile(rule).unwrap(); */

    /* println!("{rule} : {r}"); */

    /* for st in ["abc", "cba", ".abc", ".cba", ".cga"] { */
    /*     println!("{st} => {}", */
    /*         r.test(st)); */
    /* } */

    let regex = Regex::compile(".*b").unwrap();
    for m in regex.find_matches("aaaaaabaaaaaab") {
        println!("{m:#?}");
    }
}

pub fn find_matches_with_conf<'a>( &'a self, src: &'a str, conf: RegexConf, ) -> RegexMatcher<'a>

Just like find_matches, but uses a different configuration

pub fn test(&self, src: &str) -> bool

Returns true if the regex matches the given string

This is the same as calling find_matches and then checking if the iterator contains at least one element

pub fn test_with_conf(&self, src: &str, conf: RegexConf) -> bool

Just like test but with a different configuration

Trait Implementations

impl Debug for Regex

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

Formats the value using the given formatter.

impl Display for Regex

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

Formats the value using the given formatter.

impl TryFrom<&str> for Regex

type Error = RegexError

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, RegexError>

Performs the conversion.