Struct regex::RegexBuilder
[−]
[src]
pub struct RegexBuilder(_);
A configurable builder for a regular expression.
A builder can be used to configure how the regex is built, for example, by setting the default flags (which can be overridden in the expression itself) or setting various limits.
Methods
impl RegexBuilder[src]
fn new(pattern: &str) -> RegexBuilder[src]
Create a new regular expression builder with the given pattern.
If the pattern is invalid, then an error will be returned when
build is called.
fn build(&self) -> Result<Regex, Error>[src]
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.
fn case_insensitive(&mut self, yes: bool) -> &mut RegexBuilder[src]
Set the value for the case insensitive (i) flag.
When enabled, letters in the pattern will match both upper case and lower case variants.
fn multi_line(&mut self, yes: bool) -> &mut RegexBuilder[src]
Set the value for the multi-line matching (m) flag.
When enabled, ^ matches the beginning of lines and $ matches the
end of lines.
By default, they match beginning/end of the input.
fn dot_matches_new_line(&mut self, yes: bool) -> &mut RegexBuilder[src]
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.
fn swap_greed(&mut self, yes: bool) -> &mut RegexBuilder[src]
Set the value for the greedy swap (U) flag.
When enabled, a pattern like a* is lazy (tries to find shortest
match) and a*? is greedy (tries to find longest match).
By default, a* is greedy and a*? is lazy.
fn ignore_whitespace(&mut self, yes: bool) -> &mut RegexBuilder[src]
Set the value for the ignore whitespace (x) flag.
When enabled, whitespace such as new lines and spaces will be ignored
between expressions of the pattern, and # can be used to start a
comment until the next new line.
fn unicode(&mut self, yes: bool) -> &mut RegexBuilder[src]
Set the value for the Unicode (u) flag.
Enabled by default. When disabled, character classes such as \w only
match ASCII word characters instead of all Unicode word characters.
fn size_limit(&mut self, limit: usize) -> &mut RegexBuilder[src]
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.
fn dfa_size_limit(&mut self, limit: usize) -> &mut RegexBuilder[src]
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 simultaneously, then each thread may use up to the number of bytes specified here.