Struct Builder

pub struct Builder { /* private fields */ }

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:

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, 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, 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, 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(&mut self, config: Config) -> &mut Builder

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

fn syntax(&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(&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.

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Self

impl Debug for Builder

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

Auto Trait Implementations

impl !Freeze for Builder

impl !RefUnwindSafe for Builder

impl !Sync for Builder

impl Send for Builder

impl Unpin for Builder

impl UnsafeUnpin for Builder

impl UnwindSafe for Builder

Blanket Implementations

impl<T> Any for Builder where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Builder where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Builder where T: ?Sized,

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

impl<T> CloneToUninit for Builder where T: Clone,

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

impl<T> From<T> for Builder

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Builder where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for Builder where U: From<T>,

fn into(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<U> for Builder where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Builder where U: TryFrom<T>,

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