Struct `BuildError`

struct BuildError { ... }

An error that occurs when construction of a Regex fails.

A build error is generally a result of one of two possible failure modes. First is a parse or syntax error in the concrete syntax of a pattern. Second is that the construction of the underlying regex matcher fails, usually because it gets too big with respect to limits like Config::nfa_size_limit.

This error provides very little introspection capabilities. You can:

Ask for the PatternID of the pattern that caused an error, if one is available. This is available for things like syntax errors, but not for cases where build limits are exceeded.
Ask for the underlying syntax error, but only if the error is a syntax error.
Ask for a human readable message corresponding to the underlying error.
The BuildError::source method (from the std::error::Error trait implementation) may be used to query for an underlying error if one exists. There are no API guarantees about which error is returned.

When the std feature is enabled, this implements std::error::Error.

Implementations

`impl BuildError`

fn pattern(self: &Self) -> Option<PatternID>

If it is known which pattern ID caused this build error to occur, then this method returns it.

Some errors are not associated with a particular pattern. However, any errors that occur as part of parsing a pattern are guaranteed to be associated with a pattern ID.

Example

use regex_automata::{meta::Regex, PatternID};

let err = Regex::new_many(&["a", "b", r"\p{Foo}", "c"]).unwrap_err();
assert_eq!(Some(PatternID::must(2)), err.pattern());

fn size_limit(self: &Self) -> Option<usize>

If this error occurred because the regex exceeded the configured size limit before being built, then this returns the configured size limit.

The limit returned is what was configured, and corresponds to the maximum amount of heap usage in bytes.

fn syntax_error(self: &Self) -> Option<&Error>

If this error corresponds to a syntax error, then a reference to it is returned by this method.

`impl Clone for BuildError`

fn clone(self: &Self) -> BuildError

`impl Debug for BuildError`

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

`impl Display for BuildError`

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

`impl Error for BuildError`

fn source(self: &Self) -> Option<&dyn Error + 'static>

`impl Freeze for BuildError`

`impl RefUnwindSafe for BuildError`

`impl Send for BuildError`

`impl Sync for BuildError`

`impl Unpin for BuildError`

`impl UnsafeUnpin for BuildError`

`impl UnwindSafe for BuildError`

`impl<T> Any for BuildError`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BuildError`

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

`impl<T> BorrowMut for BuildError`

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

`impl<T> CloneToUninit for BuildError`

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

`impl<T> From for BuildError`

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

`impl<T> ToOwned for BuildError`

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

`impl<T> ToString for BuildError`

fn to_string(self: &Self) -> String

`impl<T, U> Into for BuildError`

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 BuildError`

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

`impl<T, U> TryInto for BuildError`

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