Struct Finder

struct Finder { ... }

A "packed pair" finder that uses 256-bit vector operations.

This finder picks two bytes that it believes have high predictive power for indicating an overall match of a needle. Depending on whether Finder::find or Finder::find_prefilter is used, it reports offsets where the needle matches or could match. In the prefilter case, candidates are reported whenever the Pair of bytes given matches.

Implementations

impl Finder

fn new(needle: &[u8]) -> Option<Finder>

Create a new pair searcher. The searcher returned can either report exact matches of needle or act as a prefilter and report candidate positions of needle.

If AVX2 is unavailable in the current environment or if a Pair could not be constructed from the needle given, then None is returned.

fn with_pair(needle: &[u8], pair: Pair) -> Option<Finder>

Create a new "packed pair" finder using the pair of bytes given.

This constructor permits callers to control precisely which pair of bytes is used as a predicate.

If AVX2 is unavailable in the current environment, then None is returned.

fn is_available() -> bool

Returns true when this implementation is available in the current environment.

When this is true, it is guaranteed that Finder::with_pair will return a Some value. Similarly, when it is false, it is guaranteed that Finder::with_pair will return a None value. Notice that this does not guarantee that Finder::new will return a Finder. Namely, even when Finder::is_available is true, it is not guaranteed that a valid Pair can be found from the needle given.

Note also that for the lifetime of a single program, if this returns true then it will always return true.

fn find(self: &Self, haystack: &[u8], needle: &[u8]) -> Option<usize>

Execute a search using AVX2 vectors and routines.

Panics

When haystack.len() is less than Finder::min_haystack_len.

fn find_prefilter(self: &Self, haystack: &[u8]) -> Option<usize>

Run this finder on the given haystack as a prefilter.

If a candidate match is found, then an offset where the needle could begin in the haystack is returned.

Panics

When haystack.len() is less than Finder::min_haystack_len.

fn pair(self: &Self) -> &Pair

Returns the pair of offsets (into the needle) used to check as a predicate before confirming whether a needle exists at a particular position.

fn min_haystack_len(self: &Self) -> usize

Returns the minimum haystack length that this Finder can search.

Using a haystack with length smaller than this in a search will result in a panic. The reason for this restriction is that this finder is meant to be a low-level component that is part of a larger substring strategy. In that sense, it avoids trying to handle all cases and instead only handles the cases that it can handle very well.

impl Clone for Finder

fn clone(self: &Self) -> Finder

impl Copy for Finder

impl Debug for Finder

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

impl Freeze for Finder

impl RefUnwindSafe for Finder

impl Send for Finder

impl Sync for Finder

impl Unpin for Finder

impl UnwindSafe for Finder

impl<T> Any for Finder

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Finder

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

impl<T> BorrowMut for Finder

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

impl<T> CloneToUninit for Finder

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

impl<T> From for Finder

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for Finder

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

impl<T, U> Into for Finder

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 Finder

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

impl<T, U> TryInto for Finder

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