Struct `Prefilter`

pub struct Prefilter { /* private fields */ }

A prefilter for accelerating a search.

This crate uses prefilters in the core search implementations to accelerate common cases. They typically only apply to cases where there are a small number of patterns (less than 100 or so), but when they do, thoughput can be boosted considerably, perhaps by an order of magnitude. When a prefilter is active, it is used whenever a search enters an automaton's start state.

Currently, prefilters cannot be constructed by callers. A Prefilter can only be accessed via the Automaton::prefilter method and used to execute a search. In other words, a prefilter can be used to optimize your own search implementation if necessary, but cannot do much else. If you have a use case for more APIs, please submit an issue.

Implementations

`impl Prefilter`

fn find_in(&self, haystack: &[u8], span: Span) -> Candidate

Execute a search in the haystack within the span given. If a match or a possible match is returned, then it is guaranteed to occur within the bounds of the span.

If the span provided is invalid for the given haystack, then behavior is unspecified.

Trait Implementations

`impl Clone for Prefilter`

fn clone(&self) -> Self

`impl Debug for Prefilter`

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

Auto Trait Implementations

`impl Freeze for Prefilter`

`impl RefUnwindSafe for Prefilter`

`impl Send for Prefilter`

`impl Sync for Prefilter`

`impl Unpin for Prefilter`

`impl UnsafeUnpin for Prefilter`

`impl UnwindSafe for Prefilter`

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

`impl<T> From<T> for Prefilter`

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

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

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

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

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

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

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