Struct Builder

struct Builder { ... }

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: &Self) -> Option<Searcher>

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

fn add<P: AsRef<[u8]>>(self: &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>(self: &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].

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 len(self: &Self) -> usize

Returns the number of patterns added to this builder.

fn minimum_len(self: &Self) -> usize

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

impl Clone for Builder

fn clone(self: &Self) -> Builder

impl Debug for Builder

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

impl Default for Builder

fn default() -> Builder

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

impl<T> Any for Builder

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Builder

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

impl<T> BorrowMut for Builder

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

impl<T> CloneToUninit for Builder

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

impl<T> From for Builder

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Builder

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

impl<T, U> Into for Builder

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 Builder

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

impl<T, U> TryInto for Builder

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