Struct `Builder`

struct Builder { ... }

A builder for a one-pass DFA.

This builder permits configuring options for the syntax of a pattern, the NFA construction and the DFA construction. 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 two different UTF-8 modes:

syntax::Config::utf8 controls whether the pattern itself can contain sub-expressions that match invalid UTF-8.
thompson::Config::utf8 controls whether empty matches that split a Unicode codepoint are reported or not.

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

Example

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

# if cfg!(miri) { return Ok(()); } // miri takes too long
use regex_automata::{
    dfa::onepass::DFA,
    nfa::thompson,
    util::syntax,
    Match,
};

let re = DFA::builder()
    .syntax(syntax::Config::new().utf8(false))
    .thompson(thompson::Config::new().utf8(false))
    .build(r"foo(?-u:[^b])ar.*")?;
let (mut cache, mut caps) = (re.create_cache(), re.create_captures());

let haystack = b"foo\xFFarzz\xE2\x98\xFF\n";
re.captures(&mut cache, haystack, &mut caps);
// Notice that `(?-u:[^b])` matches invalid UTF-8,
// but the subsequent `.*` does not! Disabling UTF-8
// on the syntax permits this.
//
// N.B. This example does not show the impact of
// disabling UTF-8 mode on a one-pass DFA Config,
//  since that only impacts regexes that can
// produce matches of length 0.
assert_eq!(Some(Match::must(0, 0..8)), caps.get_match());

# Ok::<(), Box<dyn std::error::Error>>(())

Implementations

`impl Builder`

fn new() -> Builder

Create a new one-pass DFA builder with the default configuration.

fn build(self: &Self, pattern: &str) -> Result<DFA, BuildError>

Build a one-pass DFA from the given pattern.

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

fn build_many<P: AsRef<str>>(self: &Self, patterns: &[P]) -> Result<DFA, BuildError>

Build a one-pass DFA from the given patterns.

When matches are returned, the pattern ID corresponds to the index of the pattern in the slice given.

fn build_from_nfa(self: &Self, nfa: NFA) -> Result<DFA, BuildError>

Build a DFA from the given NFA.

Example

This example shows how to build a DFA if you already have an NFA in hand.

use regex_automata::{dfa::onepass::DFA, nfa::thompson::NFA, Match};

// This shows how to set non-default options for building an NFA.
let nfa = NFA::compiler()
    .configure(NFA::config().shrink(true))
    .build(r"[a-z0-9]+")?;
let re = DFA::builder().build_from_nfa(nfa)?;
let (mut cache, mut caps) = (re.create_cache(), re.create_captures());
re.captures(&mut cache, "foo123bar", &mut caps);
assert_eq!(Some(Match::must(0, 0..9)), caps.get_match());

# Ok::<(), Box<dyn std::error::Error>>(())

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

Apply the given one-pass DFA configuration options to this builder.

fn syntax(self: &mut Self, config: Config) -> &mut Builder

Set the syntax configuration for this builder using syntax::Config.

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

These settings only apply when constructing a one-pass DFA directly from a pattern.

fn thompson(self: &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.

These settings only apply when constructing a DFA directly from a pattern.

`impl Clone for Builder`

fn clone(self: &Self) -> Builder

`impl Debug for Builder`

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

`impl Freeze for Builder`

`impl RefUnwindSafe for Builder`

`impl Send for Builder`

`impl Sync for Builder`

`impl Unpin for Builder`

`impl UnsafeUnpin for Builder`

`impl UnwindSafe for Builder`

`impl<T> Any for Builder`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Builder`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Builder`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Builder`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Builder`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Builder`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Builder`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Builder`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Builder`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>