Struct regex_cache::LazyRegexBuilder

pub struct LazyRegexBuilder { /* fields omitted */ }

A configurable builder for a lazy Regex.

Implementations

impl LazyRegexBuilder

pub fn new(source: &str) -> LazyRegexBuilder

Create a new regular expression builder with the given pattern.

If the pattern is invalid, then an error will be returned when compile is called.

pub fn build(&self) -> Result<LazyRegex, Error>

Consume the builder and compile the regular expression.

Note that calling as_str on the resulting Regex will produce the pattern given to new verbatim. Notably, it will not incorporate any of the flags set on this builder.

pub fn case_insensitive(&mut self, yes: bool) -> &mut LazyRegexBuilder

Set the value for the case insensitive (i) flag.

pub fn multi_line(&mut self, yes: bool) -> &mut LazyRegexBuilder

Set the value for the multi-line matching (m) flag.

pub fn dot_matches_new_line(&mut self, yes: bool) -> &mut LazyRegexBuilder

Set the value for the any character (s) flag, where in . matches anything when s is set and matches anything except for new line when it is not set (the default).

N.B. "matches anything" means "any byte" for regex::bytes::Regex expressions and means "any Unicode scalar value" for regex::Regex expressions.

pub fn swap_greed(&mut self, yes: bool) -> &mut LazyRegexBuilder

Set the value for the greedy swap (U) flag.

pub fn ignore_whitespace(&mut self, yes: bool) -> &mut LazyRegexBuilder

Set the value for the ignore whitespace (x) flag.

pub fn unicode(&mut self, yes: bool) -> &mut LazyRegexBuilder

Set the value for the Unicode (u) flag.

pub fn size_limit(&mut self, limit: usize) -> &mut LazyRegexBuilder

Set the approximate size limit of the compiled regular expression.

This roughly corresponds to the number of bytes occupied by a single compiled program. If the program exceeds this number, then a compilation error is returned.

pub fn dfa_size_limit(&mut self, limit: usize) -> &mut LazyRegexBuilder

Set the approximate size of the cache used by the DFA.

This roughly corresponds to the number of bytes that the DFA will use while searching.

Note that this is a per thread limit. There is no way to set a global limit. In particular, if a regex is used from multiple threads simulanteously, then each thread may use up to the number of bytes specified here.

Trait Implementations

impl Clone for LazyRegexBuilder

fn clone(&self) -> LazyRegexBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LazyRegexBuilder

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

Formats the value using the given formatter.

impl Eq for LazyRegexBuilder

impl PartialEq<LazyRegexBuilder> for LazyRegexBuilder

fn eq(&self, other: &LazyRegexBuilder) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &LazyRegexBuilder) -> bool

This method tests for !=.

impl StructuralEq for LazyRegexBuilder

impl StructuralPartialEq for LazyRegexBuilder