# Trait aho_corasick::Automaton [−] [src]

    pub trait Automaton<P> {
        fn next_state(&self, si: StateIdx, b: u8) -> StateIdx;
        fn has_match(&self, si: StateIdx, outi: usize) -> bool;
        fn get_match(&self, si: StateIdx, outi: usize, texti: usize) -> Match;
        fn start_bytes(&self) -> &[u8];
        fn patterns(&self) -> &[P];
        fn pattern(&self, i: usize) -> &P;

        fn len(&self) -> usize { ... }
        fn is_empty(&self) -> bool { ... }
        fn find<'a, 's, Q: ?Sized + AsRef<[u8]>>(
            &'a self,
            s: &'s Q
        ) -> Matches<'a, 's, P, Self>
        where
            Self: Sized,
        { ... }
        fn find_overlapping<'a, 's, Q: ?Sized + AsRef<[u8]>>(
            &'a self,
            s: &'s Q
        ) -> MatchesOverlapping<'a, 's, P, Self>
        where
            Self: Sized,
        { ... }
        fn stream_find<'a, R: Read>(
            &'a self,
            rdr: R
        ) -> StreamMatches<'a, R, P, Self>
        where
            Self: Sized,
        { ... }
        fn stream_find_overlapping<'a, R: Read>(
            &'a self,
            rdr: R
        ) -> StreamMatchesOverlapping<'a, R, P, Self>
        where
            Self: Sized,
        { ... }
    }

An abstraction over automatons and their corresponding iterators. The type parameter `P` is the type of the pattern that was used to construct this Automaton.

## Required Methods

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

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

### `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 get_match(&self, si: StateIdx, outi: usize, texti: usize) -> Match`

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

### `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.

The order of the patterns is the order in which they were added.

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

Returns the pattern indexed at `i`.

The index corresponds to the position at which the pattern was added to the automaton, starting at `0`.

## Provided Methods

### `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.

### `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`.

### `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`.

### `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.

### `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.

## Implementors

- `impl<'a, P: AsRef<[u8]>, A: 'a + Automaton<P> + ?Sized> Automaton<P> for &'a A`
- `impl<P: AsRef<[u8]>> Automaton<P> for FullAcAutomaton<P>`
- `impl<P: AsRef<[u8]>, T: Transitions> Automaton<P> for AcAutomaton<P, T>`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)