Struct regex_automata::dfa::regex::Builder

pub struct Builder { /* private fields */ }

A builder for a regex based on deterministic finite automatons.

This builder permits configuring options for the syntax of a pattern, the NFA construction, the DFA construction and finally the regex searching itself. This builder is different from a general purpose regex builder in that it permits fine grain configuration of the construction process. The trade off for this is complexity, and the possibility of setting a configuration that might not make sense. For example, there are three different UTF-8 modes:

• SyntaxConfig::utf8 controls whether the pattern itself can contain sub-expressions that match invalid UTF-8.
• nfa::thompson::Config::utf8 controls whether the implicit unanchored prefix added to the NFA can match through invalid UTF-8 or not.
• Config::utf8 controls how the regex iterators themselves advance the starting position of the next search when a match with zero length is found.

Generally speaking, callers will want to either enable all of these or disable all of these.

Internally, building a regex requires building two DFAs, where one is responsible for finding the end of a match and the other is responsible for finding the start of a match. If you only need to detect whether something matched, or only the end of a match, then you should use a dense::Builder to construct a single DFA, which is cheaper than building two DFAs.

Build methods

This builder has a few “build” methods. In general, it’s the result of combining the following parameters:

• Building one or many regexes.
• Building a regex with dense or sparse DFAs.

The simplest “build” method is Builder::build. It accepts a single pattern and builds a dense DFA using usize for the state identifier representation.

The most general “build” method is Builder::build_many, which permits building a regex that searches for multiple patterns simultaneously while using a specific state identifier representation.

The most flexible “build” method, but hardest to use, is Builder::build_from_dfas. This exposes the fact that a Regex is just a pair of DFAs, and this method allows you to specify those DFAs exactly.

Example

This example shows how to disable UTF-8 mode in the syntax, the NFA and the regex itself. This is generally what you want for matching on arbitrary bytes.

use regex_automata::{
    dfa::regex::Regex, nfa::thompson, MultiMatch, SyntaxConfig
};

let re = Regex::builder()
    .configure(Regex::config().utf8(false))
    .syntax(SyntaxConfig::new().utf8(false))
    .thompson(thompson::Config::new().utf8(false))
    .build(r"foo(?-u:[^b])ar.*")?;
let haystack = b"\xFEfoo\xFFarzz\xE2\x98\xFF\n";
let expected = Some(MultiMatch::must(0, 1, 9));
let got = re.find_leftmost(haystack);
assert_eq!(expected, got);
// Notice that `(?-u:[^b])` matches invalid UTF-8,
// but the subsequent `.*` does not! Disabling UTF-8
// on the syntax permits this. Notice also that the
// search was unanchored and skipped over invalid UTF-8.
// Disabling UTF-8 on the Thompson NFA permits this.
//
// N.B. This example does not show the impact of
// disabling UTF-8 mode on Config, since that
// only impacts regexes that can produce matches of
// length 0.
assert_eq!(b"foo\xFFarzz", &haystack[got.unwrap().range()]);

Implementations

impl Builder

pub fn new() -> Builder

Create a new regex builder with the default configuration.

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

Build a regex from the given pattern.

If there was a problem parsing or compiling the pattern, then an error is returned.

pub fn build_sparse(&self, pattern: &str) -> Result<Regex<DFA<Vec<u8>>>, Error>

Build a regex from the given pattern using sparse DFAs.

If there was a problem parsing or compiling the pattern, then an error is returned.

pub fn build_many<P: AsRef<str>>(&self, patterns: &[P]) -> Result<Regex, Error>

Build a regex from the given patterns.

pub fn build_many_sparse<P: AsRef<str>>(
    &self,
    patterns: &[P]
) -> Result<Regex<DFA<Vec<u8>>>, Error>

Build a sparse regex from the given patterns.

pub fn build_from_dfas<A: Automaton>(&self, forward: A, reverse: A) -> Regex<A>

Build a regex from its component forward and reverse DFAs.

This is useful when deserializing a regex from some arbitrary memory region. This is also useful for building regexes from other types of DFAs.

If you’re building the DFAs from scratch instead of building new DFAs from other DFAs, then you’ll need to make sure that the reverse DFA is configured correctly to match the intended semantics. Namely:

• It should be anchored.
• It should use MatchKind::All semantics.
• It should match in reverse.
• It should have anchored start states compiled for each pattern.
• Otherwise, its configuration should match the forward DFA.

If these conditions are satisfied, then behavior of searches is unspecified.

Note that when using this constructor, only the configuration from Config is applied. The only configuration settings on this builder only apply when the builder owns the construction of the DFAs themselves.

Example

This example is a bit a contrived. The usual use of these methods would involve serializing initial_re somewhere and then deserializing it later to build a regex. But in this case, we do everything in memory.

use regex_automata::dfa::regex::Regex;

let initial_re = Regex::new("foo[0-9]+")?;
assert_eq!(true, initial_re.is_match(b"foo123"));

let (fwd, rev) = (initial_re.forward(), initial_re.reverse());
let re = Regex::builder().build_from_dfas(fwd, rev);
assert_eq!(true, re.is_match(b"foo123"));

This example shows how to build a Regex that uses sparse DFAs instead of dense DFAs without using one of the convenience build_sparse routines:

use regex_automata::dfa::regex::Regex;

let initial_re = Regex::new("foo[0-9]+")?;
assert_eq!(true, initial_re.is_match(b"foo123"));

let fwd = initial_re.forward().to_sparse()?;
let rev = initial_re.reverse().to_sparse()?;
let re = Regex::builder().build_from_dfas(fwd, rev);
assert_eq!(true, re.is_match(b"foo123"));

pub fn configure(&mut self, config: Config) -> &mut Builder

Apply the given regex configuration options to this builder.

pub fn syntax(&mut self, config: SyntaxConfig) -> &mut Builder

Set the syntax configuration for this builder using SyntaxConfig.

This permits setting things like case insensitivity, Unicode and multi line mode.

pub fn thompson(&mut self, config: Config) -> &mut Builder

Set the Thompson NFA configuration for this builder using nfa::thompson::Config.

This permits setting things like whether additional time should be spent shrinking the size of the NFA.

pub fn dense(&mut self, config: Config) -> &mut Builder

Set the dense DFA compilation configuration for this builder using dense::Config.

This permits setting things like whether the underlying DFAs should be minimized.

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Builder

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

Formats the value using the given formatter.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.