Enum regex_automata::MatchErrorKind

#[non_exhaustive]
pub enum MatchErrorKind {
    Quit {
        byte: u8,
        offset: usize,
    },
    GaveUp {
        offset: usize,
    },
    HaystackTooLong {
        len: usize,
    },
    UnsupportedAnchored {
        mode: Anchored,
    },
}

The underlying kind of a MatchError.

This is a non-exhaustive enum. That means new variants may be added in a semver-compatible release.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Quit

Fields

byte: u8

The “quit” byte that was observed that caused the search to stop.

offset: usize

The offset at which the quit byte was observed.

The search saw a “quit” byte at which it was instructed to stop searching.

GaveUp

Fields

offset: usize

The offset at which the search stopped. This corresponds to the position immediately following the last byte scanned.

The search, based on heuristics, determined that it would be better to stop, typically to provide the caller an opportunity to use an alternative regex engine.

Currently, the only way for this to occur is via the lazy DFA and only when it is configured to do so (it will not return this error by default).

HaystackTooLong

Fields

len: usize

The length of the haystack that exceeded the limit.

This error occurs if the haystack given to the regex engine was too long to be searched. This occurs, for example, with regex engines like the bounded backtracker that have a configurable fixed amount of capacity that is tied to the length of the haystack. Anything beyond that configured limit will result in an error at search time.

UnsupportedAnchored

Fields

mode: Anchored

The anchored mode given that is unsupported.

An error indicating that a particular type of anchored search was requested, but that the regex engine does not support it.

Note that this error should not be returned by a regex engine simply because the pattern ID is invalid (i.e., equal to or exceeds the number of patterns in the regex). In that case, the regex engine should report a non-match.

Trait Implementations

impl Clone for MatchErrorKind

fn clone(&self) -> MatchErrorKind

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MatchErrorKind

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

Formats the value using the given formatter.

impl PartialEq for MatchErrorKind

fn eq(&self, other: &MatchErrorKind) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for MatchErrorKind

impl StructuralEq for MatchErrorKind

impl StructuralPartialEq for MatchErrorKind