Struct split_by::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> AcAutomaton<P, Dense> where
    P: AsRef<[u8]>, 

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, T> AcAutomaton<P, T> where
    P: AsRef<[u8]>,
    T: Transitions, 

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<S> FromIterator<S> for AcAutomaton<S, Dense> where
    S: AsRef<[u8]>, 

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

Create an automaton from an iterator of strings.

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

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

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

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

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

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

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

Important traits for &'a mut [u8]

impl<'a> Write for &'a mut [u8]impl<'a> Read for &'a [u8]

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

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

Important traits for &'a mut [u8]

impl<'a> Write for &'a mut [u8]impl<'a> Read for &'a [u8]

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

Returns all of the patterns matched by this automaton.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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> Iterator for Matches<'a, 's, P, A> where
    A: Automaton<P> + ?Sized,  type Item = Match;

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

Returns an iterator of non-overlapping matches in s.

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

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

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

Returns an iterator of overlapping matches in s.

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

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

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

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

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

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

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

Returns an iterator of overlapping matches in the given reader.

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

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, T> Debug for AcAutomaton<P, T> where
    P: AsRef<[u8]> + Debug,
    T: Transitions, 

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

Formats the value using the given formatter.