MatchErrorKind in regex_automata - Rust (original) (raw)
Enum MatchErrorKind
#[non_exhaustive]
pub enum MatchErrorKind {
Quit {
byte: u8,
offset: usize,
},
GaveUp {
offset: usize,
},
HaystackTooLong {
len: usize,
},
UnsupportedAnchored {
mode: Anchored,
},
}Expand description
The underlying kind of a MatchError.
This is a non-exhaustive enum. That means new variants may be added in a semver-compatible release.
This enum is marked as 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.
The search saw a “quit” byte at which it was instructed to stop searching.
Fields
The “quit” byte that was observed that caused the search to stop.
The offset at which the quit byte was observed.
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).
Fields
The offset at which the search stopped. This corresponds to the position immediately following the last byte scanned.
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.
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.
Fields
The anchored mode given that is unsupported.
Tests for self and other values to be equal, and is used by ==.
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.