Struct TranslatorBuilder

struct TranslatorBuilder { ... }

A builder for constructing an AST->HIR translator.

Implementations

impl TranslatorBuilder

fn new() -> TranslatorBuilder

Create a new translator builder with a default c onfiguration.

fn build(self: &Self) -> Translator

Build a translator using the current configuration.

fn utf8(self: &mut Self, yes: bool) -> &mut TranslatorBuilder

When disabled, translation will permit the construction of a regular expression that may match invalid UTF-8.

When enabled (the default), the translator is guaranteed to produce an expression that, for non-empty matches, will only ever produce spans that are entirely valid UTF-8 (otherwise, the translator will return an error).

Perhaps surprisingly, when UTF-8 is enabled, an empty regex or even a negated ASCII word boundary (uttered as (?-u:\B) in the concrete syntax) will be allowed even though they can produce matches that split a UTF-8 encoded codepoint. This only applies to zero-width or "empty" matches, and it is expected that the regex engine itself must handle these cases if necessary (perhaps by suppressing any zero-width matches that split a codepoint).

fn line_terminator(self: &mut Self, byte: u8) -> &mut TranslatorBuilder

Sets the line terminator for use with (?u-s:.) and (?-us:.).

Namely, instead of . (by default) matching everything except for \n, this will cause . to match everything except for the byte given.

If . is used in a context where Unicode mode is enabled and this byte isn't ASCII, then an error will be returned. When Unicode mode is disabled, then any byte is permitted, but will return an error if UTF-8 mode is enabled and it is a non-ASCII byte.

In short, any ASCII value for a line terminator is always okay. But a non-ASCII byte might result in an error depending on whether Unicode mode or UTF-8 mode are enabled.

Note that if R mode is enabled then it always takes precedence and the line terminator will be treated as \r and \n simultaneously.

Note also that this doesn't impact the look-around assertions (?m:^) and (?m:$). That's usually controlled by additional configuration in the regex engine itself.

fn case_insensitive(self: &mut Self, yes: bool) -> &mut TranslatorBuilder

Enable or disable the case insensitive flag (i) by default.

fn multi_line(self: &mut Self, yes: bool) -> &mut TranslatorBuilder

Enable or disable the multi-line matching flag (m) by default.

fn dot_matches_new_line(self: &mut Self, yes: bool) -> &mut TranslatorBuilder

Enable or disable the "dot matches any character" flag (s) by default.

fn crlf(self: &mut Self, yes: bool) -> &mut TranslatorBuilder

Enable or disable the CRLF mode flag (R) by default.

fn swap_greed(self: &mut Self, yes: bool) -> &mut TranslatorBuilder

Enable or disable the "swap greed" flag (U) by default.

fn unicode(self: &mut Self, yes: bool) -> &mut TranslatorBuilder

Enable or disable the Unicode flag (u) by default.

impl Clone for TranslatorBuilder

fn clone(self: &Self) -> TranslatorBuilder

impl Debug for TranslatorBuilder

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

impl Default for TranslatorBuilder

fn default() -> TranslatorBuilder

impl Freeze for TranslatorBuilder

impl RefUnwindSafe for TranslatorBuilder

impl Send for TranslatorBuilder

impl Sync for TranslatorBuilder

impl Unpin for TranslatorBuilder

impl UnsafeUnpin for TranslatorBuilder

impl UnwindSafe for TranslatorBuilder

impl<T> Any for TranslatorBuilder

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for TranslatorBuilder

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

impl<T> BorrowMut for TranslatorBuilder

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

impl<T> CloneToUninit for TranslatorBuilder

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

impl<T> From for TranslatorBuilder

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for TranslatorBuilder

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

impl<T, U> Into for TranslatorBuilder

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 TranslatorBuilder

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

impl<T, U> TryInto for TranslatorBuilder

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