Struct aho_corasick::AcAutomaton

pub struct AcAutomaton<P, T = Dense> { /* fields omitted */ }

An Aho-Corasick finite automaton.

The type parameter P is the type of the pattern that was used to construct this AcAutomaton.

Methods

impl<P: AsRef<[u8]>> AcAutomaton<P>

pub fn new<I>(pats: I) -> AcAutomaton<P, Dense> where
    I: IntoIterator<Item = P>, 

Create a new automaton from an iterator of patterns.

The patterns must be convertible to bytes (&[u8]) via the AsRef trait.

impl<P: AsRef<[u8]>, T: Transitions> AcAutomaton<P, T>

pub fn with_transitions<I>(pats: I) -> AcAutomaton<P, T> where
    I: IntoIterator<Item = P>, 

Create a new automaton from an iterator of patterns.

This constructor allows one to choose the transition representation.

The patterns must be convertible to bytes (&[u8]) via the AsRef trait.

pub fn into_full(self) -> FullAcAutomaton<P>

Build out the entire automaton into a single matrix.

This will make searching as fast as possible at the expense of using at least 4 * 256 * #states bytes of memory.

Trait Implementations

impl<P: AsRef<[u8]>, T: Transitions> Automaton<P> for AcAutomaton<P, T>

fn next_state(&self, si: StateIdx, b: u8) -> StateIdx

Return the next state given the current state and next character.

fn get_match(&self, si: StateIdx, outi: usize, texti: usize) -> Match

Build a match given the current state, pattern index and input index.

fn has_match(&self, si: StateIdx, outi: usize) -> bool

Return true if and only if the given state and current pattern index indicate a match.

fn start_bytes(&self) -> &[u8]

Return the set of bytes that have transitions in the root state.

fn patterns(&self) -> &[P]

Returns all of the patterns matched by this automaton.

fn pattern(&self, i: usize) -> &P

Returns the pattern indexed at i.

fn len(&self) -> usize

Return the number of patterns in the automaton.

fn is_empty(&self) -> bool

Returns true if the automaton has no patterns.

Important traits for Matches<'a, 's, P, A>

impl<'a, 's, P, A: Automaton<P> + ?Sized> Iterator for Matches<'a, 's, P, A> type Item = Match;

fn find<'a, 's, Q: ?Sized + AsRef<[u8]>>(
    &'a self,
    s: &'s Q
) -> Matches<'a, 's, P, Self> where
    Self: Sized, 

Returns an iterator of non-overlapping matches in s.

Important traits for MatchesOverlapping<'a, 's, P, A>

impl<'a, 's, P, A: Automaton<P> + ?Sized> Iterator for MatchesOverlapping<'a, 's, P, A> type Item = Match;

fn find_overlapping<'a, 's, Q: ?Sized + AsRef<[u8]>>(
    &'a self,
    s: &'s Q
) -> MatchesOverlapping<'a, 's, P, Self> where
    Self: Sized, 

Returns an iterator of overlapping matches in s.

Important traits for StreamMatches<'a, R, P, A>

impl<'a, R: Read, P, A: Automaton<P>> Iterator for StreamMatches<'a, R, P, A> type Item = Result<Match>;

fn stream_find<'a, R: Read>(&'a self, rdr: R) -> StreamMatches<'a, R, P, Self> where
    Self: Sized, 

Returns an iterator of non-overlapping matches in the given reader.

Important traits for StreamMatchesOverlapping<'a, R, P, A>

impl<'a, R: Read, P, A: Automaton<P> + ?Sized> Iterator for StreamMatchesOverlapping<'a, R, P, A> type Item = Result<Match>;

fn stream_find_overlapping<'a, R: Read>(
    &'a self,
    rdr: R
) -> StreamMatchesOverlapping<'a, R, P, Self> where
    Self: Sized, 

Returns an iterator of overlapping matches in the given reader.

impl<P: Clone, T: Clone> Clone for AcAutomaton<P, T>

fn clone(&self) -> AcAutomaton<P, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: AsRef<[u8]> + Debug, T: Transitions> Debug for AcAutomaton<P, T>

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

Formats the value using the given formatter.

impl<S: AsRef<[u8]>> FromIterator<S> for AcAutomaton<S>

fn from_iter<T>(it: T) -> AcAutomaton<S> where
    T: IntoIterator<Item = S>, 

Create an automaton from an iterator of strings.