Builder in regex_automata::dfa::dense - Rust (original) (raw)

pub struct Builder { /* private fields */ }

Available on (crate features dfa-search or dfa-onepass) and crate feature dfa-search and crate feature dfa-build only.

Expand description

A builder for constructing a deterministic finite automaton from regular expressions.

This builder provides two main things:

It provides a few different build routines for actually constructing a DFA from different kinds of inputs. The most convenient isBuilder::build, which builds a DFA directly from a pattern string. The most flexible is Builder::build_from_nfa, which builds a DFA straight from an NFA.
The builder permits configuring a number of things.Builder::configure is used with Config to configure aspects of the DFA and the construction process itself. Builder::syntax andBuilder::thompson permit configuring the regex parser and Thompson NFA construction, respectively. The syntax and thompson configurations only apply when building from a pattern string.

This builder always constructs a single DFA. As such, this builder can only be used to construct regexes that either detect the presence of a match or find the end location of a match. A single DFA cannot produce both the start and end of a match. For that information, use aRegex, which can be similarly configured using regex::Builder. The main reason to use a DFA directly is if the end location of a match is enough for your use case. Namely, a Regex will construct two DFAs instead of one, since a second reverse DFA is needed to find the start of a match.

Note that if one wants to build a sparse DFA, you must first build a dense DFA and convert that to a sparse DFA. There is no way to build a sparse DFA without first building a dense DFA.

§Example

This example shows how to build a minimized DFA that completely disables Unicode. That is:

Things such as \w, . and \b are no longer Unicode-aware. \wand \b are ASCII-only while . matches any byte except for \n(instead of any UTF-8 encoding of a Unicode scalar value except for\n). Things that are Unicode only, such as \pL, are not allowed.
The pattern itself is permitted to match invalid UTF-8. For example, things like [^a] that match any byte except for a are permitted.

use regex_automata::{
    dfa::{Automaton, dense},
    util::syntax,
    HalfMatch, Input,
};

let dfa = dense::Builder::new()
    .configure(dense::Config::new().minimize(false))
    .syntax(syntax::Config::new().unicode(false).utf8(false))
    .build(r"foo[^b]ar.*")?;

let haystack = b"\xFEfoo\xFFar\xE2\x98\xFF\n";
let expected = Some(HalfMatch::must(0, 10));
let got = dfa.try_search_fwd(&Input::new(haystack))?;
assert_eq!(expected, got);

Source §

Source

Create a new dense DFA builder with the default configuration.

Source

Available on crate feature syntax only.

Build a DFA from the given pattern.

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

Source

Available on crate feature syntax only.

Build a DFA from the given patterns.

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

Source

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::{Automaton, dense},
    nfa::thompson::NFA,
    HalfMatch, Input,
};

let haystack = "foo123bar".as_bytes();

// This shows how to set non-default options for building an NFA.
let nfa = NFA::compiler()
    .configure(NFA::config().shrink(true))
    .build(r"[0-9]+")?;
let dfa = dense::Builder::new().build_from_nfa(&nfa)?;
let expected = Some(HalfMatch::must(0, 6));
let got = dfa.try_search_fwd(&Input::new(haystack))?;
assert_eq!(expected, got);

Source

Apply the given dense DFA configuration options to this builder.

Source

Available on crate feature syntax only.

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

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

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

Source

Available on crate feature syntax only.

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

This permits setting things like whether the DFA should match the regex in reverse or if additional time should be spent shrinking the size of the NFA.

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