Struct `Builder`

pub struct Builder { /* private fields */ }

A builder for constructing a packed searcher from a collection of patterns.

Example

This example shows how to use a builder to construct a searcher. By default, leftmost-first match semantics are used.

use aho_corasick::{packed::{Builder, MatchKind}, PatternID};

# fn example() -> Option<()> {
let searcher = Builder::new()
    .add("foobar")
    .add("foo")
    .build()?;
let matches: Vec<PatternID> = searcher
    .find_iter("foobar")
    .map(|mat| mat.pattern())
    .collect();
assert_eq!(vec![PatternID::ZERO], matches);
# Some(()) }
# if cfg!(all(feature = "std", any(
#     target_arch = "x86_64", target_arch = "aarch64",
# ))) {
#     example().unwrap()
# } else {
#     assert!(example().is_none());
# }

Implementations

`impl Builder`

fn new() -> Builder

Create a new builder for constructing a multi-pattern searcher. This constructor uses the default configuration.

fn build(&self) -> Option<Searcher>

Build a searcher from the patterns added to this builder so far.

fn add<P: AsRef<[u8]>>(&mut self, pattern: P) -> &mut Builder

Add the given pattern to this set to match.

The order in which patterns are added is significant. Namely, when using leftmost-first match semantics, then when multiple patterns can match at a particular location, the pattern that was added first is used as the match.

If the number of patterns added exceeds the amount supported by packed searchers, then the builder will stop accumulating patterns and render itself inert. At this point, constructing a searcher will always return None.

fn extend<I, P>(&mut self, patterns: I) -> &mut Builder where I: IntoIterator<Item = P>, P: AsRef<[u8]>,

Add the given iterator of patterns to this set to match.

The iterator must yield elements that can be converted into a &[u8].

fn len(&self) -> usize

Returns the number of patterns added to this builder.

fn minimum_len(&self) -> usize

Returns the length, in bytes, of the shortest pattern added.

Trait Implementations

`impl Clone for Builder`

fn clone(&self) -> Self

`impl Debug for Builder`

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

`impl Default for Builder`

fn default() -> Builder

Auto Trait Implementations

`impl Freeze for Builder`

`impl RefUnwindSafe for Builder`

`impl Send for Builder`

`impl Sync for Builder`

`impl Unpin for Builder`

`impl UnsafeUnpin for Builder`

`impl UnwindSafe for Builder`

Blanket Implementations

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

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Builder where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Builder where T: ?Sized,`

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

`impl<T> CloneToUninit for Builder where T: Clone,`

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

`impl<T> From<T> for Builder`

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

`impl<T> ToOwned for Builder where T: Clone,`

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

`impl<T, U> Into for Builder 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 for Builder where U: Into<T>,`

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

`impl<T, U> TryInto for Builder where U: TryFrom<T>,`

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