Struct regex::bytes::RegexSetBuilder [] [src]

pub struct RegexSetBuilder(_);

A configurable builder for a set of regular expressions.

A builder can be used to configure how the regexes are built, for example, by setting the default flags (which can be overridden in the expression itself) or setting various limits.

Methods

impl RegexSetBuilder
[src]

[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.

[src]

Consume the builder and compile the regular expressions into a set.

[src]

Set the value for the case insensitive (i) flag.

[src]

Set the value for the multi-line matching (m) flag.

[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::RegexSet expressions and means "any Unicode scalar value" for regex::RegexSet expressions.

[src]

Set the value for the greedy swap (U) flag.

[src]

Set the value for the ignore whitespace (x) flag.

[src]

Set the value for the Unicode (u) flag.

[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.

[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 simulanteously, then each thread may use up to the number of bytes specified here.

[src]

Set the nesting limit for this parser.

The nesting limit controls how deep the abstract syntax tree is allowed to be. If the AST exceeds the given limit (e.g., with too many nested groups), then an error is returned by the parser.

The purpose of this limit is to act as a heuristic to prevent stack overflow for consumers that do structural induction on an Ast using explicit recursion. While this crate never does this (instead using constant stack space and moving the call stack to the heap), other crates may.

This limit is not checked until the entire Ast is parsed. Therefore, if callers want to put a limit on the amount of heap space used, then they should impose a limit on the length, in bytes, of the concrete pattern string. In particular, this is viable since this parser implementation will limit itself to heap space proportional to the lenth of the pattern string.

Note that a nest limit of 0 will return a nest limit error for most patterns but not all. For example, a nest limit of 0 permits a but not ab, since ab requires a concatenation, which results in a nest depth of 1. In general, a nest limit is not something that manifests in an obvious way in the concrete syntax, therefore, it should not be used in a granular way.

Trait Implementations

Auto Trait Implementations