Struct Match

pub struct Match { /* private fields */ }

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) -> 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) -> usize

The starting position of the match.

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

fn end(&self) -> usize

The ending position of the match.

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

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

Returns the match span as a range.

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

fn span(&self) -> Span

Returns the span for this match.

fn is_empty(&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) -> usize

Returns the length of this match.

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

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

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

Panics

This panics if adding offset to either part of this match's Span would result in overflow.

Trait Implementations

impl Clone for Match

fn clone(&self) -> Self

impl Copy for Match

impl Debug for Match

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

impl Eq for Match

impl Hash for Match

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

impl PartialEq for Match

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

impl StructuralPartialEq for Match

Auto Trait Implementations

impl Freeze for Match

impl RefUnwindSafe for Match

impl Send for Match

impl Sync for Match

impl Unpin for Match

impl UnsafeUnpin for Match

impl UnwindSafe for Match

Blanket Implementations

impl<T> Any for Match where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Match where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Match where T: ?Sized,

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

impl<T> CloneToUninit for Match where T: Clone,

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

impl<T> From<T> for Match

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Match where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for Match where U: From<T>,

fn into(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<U> for Match where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Match where U: TryFrom<T>,

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