Struct `OverlappingState`

struct OverlappingState { ... }

Represents the current state of an overlapping search.

This is used for overlapping searches since they need to know something about the previous search. For example, when multiple patterns match at the same position, this state tracks the last reported pattern so that the next search knows whether to report another matching pattern or continue with the search at the next position. Additionally, it also tracks which state the last search call terminated in and the current offset of the search in the haystack.

This type provides limited introspection capabilities. The only thing a caller can do is construct it and pass it around to permit search routines to use it to track state, and to ask whether a match has been found.

Callers should always provide a fresh state constructed via OverlappingState::start when starting a new search. That same state should be reused for subsequent searches on the same Input. The state given will advance through the haystack itself. Callers can detect the end of a search when neither an error nor a match is returned.

Example

This example shows how to manually iterate over all overlapping matches. If you need this, you might consider using AhoCorasick::find_overlapping_iter instead, but this shows how to correctly use an OverlappingState.

use aho_corasick::{
    automaton::OverlappingState,
    AhoCorasick, Input, Match,
};

let patterns = &["append", "appendage", "app"];
let haystack = "append the app to the appendage";

let ac = AhoCorasick::new(patterns).unwrap();
let mut state = OverlappingState::start();
let mut matches = vec![];

loop {
    ac.find_overlapping(haystack, &mut state);
    let mat = match state.get_match() {
        None => break,
        Some(mat) => mat,
    };
    matches.push(mat);
}
let expected = vec![
    Match::must(2, 0..3),
    Match::must(0, 0..6),
    Match::must(2, 11..14),
    Match::must(2, 22..25),
    Match::must(0, 22..28),
    Match::must(1, 22..31),
];
assert_eq!(expected, matches);

Implementations

`impl OverlappingState`

fn start() -> OverlappingState

Create a new overlapping state that begins at the start state.

fn get_match(self: &Self) -> Option<Match>

Return the match result of the most recent search to execute with this state.

Every search will clear this result automatically, such that if no match is found, this will always correctly report None.

`impl Clone for OverlappingState`

fn clone(self: &Self) -> OverlappingState

`impl Debug for OverlappingState`

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

`impl Freeze for OverlappingState`

`impl RefUnwindSafe for OverlappingState`

`impl Send for OverlappingState`

`impl Sync for OverlappingState`

`impl Unpin for OverlappingState`

`impl UnsafeUnpin for OverlappingState`

`impl UnwindSafe for OverlappingState`

`impl<T> Any for OverlappingState`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for OverlappingState`

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

`impl<T> BorrowMut for OverlappingState`

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

`impl<T> CloneToUninit for OverlappingState`

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

`impl<T> From for OverlappingState`

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

`impl<T> ToOwned for OverlappingState`

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

`impl<T, U> Into for OverlappingState`

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

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

`impl<T, U> TryInto for OverlappingState`

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