Struct `Match`

struct Match { ... }

A representation of a match reported by an Aho-Corasick searcher.

A match has two essential pieces of information: the PatternID that matches, and the Span of the match in a haystack.

The pattern is identified by an ID, which corresponds to its position (starting from 0) relative to other patterns used to construct the corresponding searcher. If only a single pattern is provided, then all matches are guaranteed to have a pattern ID of 0.

Every match reported by a searcher guarantees that its span has its start offset as less than or equal to its end offset.

Implementations

`impl Match`

fn new<S: Into<Span>>(pattern: PatternID, span: S) -> Match

Create a new match from a pattern ID and a span.

This constructor is generic over how a span is provided. While a Span may be given directly, one may also provide a std::ops::Range<usize>.

Panics

This panics if end < start.

Example

This shows how to create a match for the first pattern in an Aho-Corasick searcher using convenient range syntax.

use aho_corasick::{Match, PatternID};

let m = Match::new(PatternID::ZERO, 5..10);
assert_eq!(0, m.pattern().as_usize());
assert_eq!(5, m.start());
assert_eq!(10, m.end());

fn must<S: Into<Span>>(pattern: usize, span: S) -> Match

Create a new match from a pattern ID and a byte offset span.

This constructor is generic over how a span is provided. While a Span may be given directly, one may also provide a std::ops::Range<usize>.

This is like Match::new, but accepts a usize instead of a PatternID. This panics if the given usize is not representable as a PatternID.

Panics

This panics if end < start or if pattern > PatternID::MAX.

Example

This shows how to create a match for the third pattern in an Aho-Corasick searcher using convenient range syntax.

use aho_corasick::Match;

let m = Match::must(3, 5..10);
assert_eq!(3, m.pattern().as_usize());
assert_eq!(5, m.start());
assert_eq!(10, m.end());

fn pattern(self: &Self) -> PatternID

Returns the ID of the pattern that matched.

The ID of a pattern is derived from the position in which it was originally inserted into the corresponding searcher. The first pattern has identifier 0, and each subsequent pattern is 1, 2 and so on.

fn start(self: &Self) -> usize

The starting position of the match.

This is a convenience routine for Match::span().start.

fn end(self: &Self) -> usize

The ending position of the match.

This is a convenience routine for Match::span().end.

fn range(self: &Self) -> Range<usize>

Returns the match span as a range.

This is a convenience routine for Match::span().range().

fn span(self: &Self) -> Span

Returns the span for this match.

fn is_empty(self: &Self) -> bool

Returns true when the span in this match is empty.

An empty match can only be returned when empty pattern is in the Aho-Corasick searcher.

fn len(self: &Self) -> usize

Returns the length of this match.

This returns 0 in precisely the cases that is_empty returns true.

fn offset(self: &Self, offset: usize) -> Match

Returns a new match with offset added to its span's start and end values.

`impl Clone for Match`

fn clone(self: &Self) -> Match

`impl Copy for Match`

`impl Debug for Match`

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

`impl Eq for Match`

`impl Freeze for Match`

`impl Hash for Match`

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

`impl PartialEq for Match`

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

`impl RefUnwindSafe for Match`

`impl Send for Match`

`impl StructuralPartialEq for Match`

`impl Sync for Match`

`impl Unpin for Match`

`impl UnsafeUnpin for Match`

`impl UnwindSafe for Match`

`impl<T> Any for Match`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Match`

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

`impl<T> BorrowMut for Match`

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

`impl<T> CloneToUninit for Match`

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

`impl<T> From for Match`

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

`impl<T> ToOwned for Match`

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

`impl<T, U> Into for Match`

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

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

`impl<T, U> TryInto for Match`

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