Struct `FinderReverse`

struct FinderReverse<'a>(_)

A single substring reverse searcher fixed to a particular needle.

The purpose of this type is to permit callers to construct a substring searcher that can be used to search haystacks without the overhead of constructing the searcher in the first place. This is a somewhat niche concern when it's necessary to re-use the same needle to search multiple different haystacks with as little overhead as possible. In general, using ByteSlice::rfind or ByteSlice::rfind_iter is good enough, but FinderReverse is useful when you can meaningfully observe searcher construction time in a profile.

When the std feature is enabled, then this type has an into_owned version which permits building a FinderReverse that is not connected to the lifetime of its needle.

Implementations

`impl<'a> FinderReverse<'a>`

fn new<B: ?Sized + AsRef<[u8]>>(needle: &'a B) -> FinderReverse<'a>

Create a new reverse finder for the given needle.

fn into_owned(self: Self) -> FinderReverse<'static>

Convert this finder into its owned variant, such that it no longer borrows the needle.

If this is already an owned finder, then this is a no-op. Otherwise, this copies the needle.

This is only available when the alloc feature is enabled.

fn needle(self: &Self) -> &[u8]

Returns the needle that this finder searches for.

Note that the lifetime of the needle returned is tied to the lifetime of this finder, and may be shorter than the 'a lifetime. Namely, a finder's needle can be either borrowed or owned, so the lifetime of the needle returned must necessarily be the shorter of the two.

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

Returns the index of the last occurrence of this needle in the given haystack.

The haystack may be any type that can be cheaply converted into a &[u8]. This includes, but is not limited to, &str and &[u8].

Complexity

This routine is guaranteed to have worst case linear time complexity with respect to both the needle and the haystack. That is, this runs in O(needle.len() + haystack.len()) time.

This routine is also guaranteed to have worst case constant space complexity.

Examples

Basic usage:

use bstr::FinderReverse;

let haystack = "foo bar baz";
assert_eq!(Some(0), FinderReverse::new("foo").rfind(haystack));
assert_eq!(Some(4), FinderReverse::new("bar").rfind(haystack));
assert_eq!(None, FinderReverse::new("quux").rfind(haystack));

`impl<'a> Clone for FinderReverse<'a>`

fn clone(self: &Self) -> FinderReverse<'a>

`impl<'a> Debug for FinderReverse<'a>`

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

`impl<'a> Freeze for FinderReverse<'a>`

`impl<'a> RefUnwindSafe for FinderReverse<'a>`

`impl<'a> Send for FinderReverse<'a>`

`impl<'a> Sync for FinderReverse<'a>`

`impl<'a> Unpin for FinderReverse<'a>`

`impl<'a> UnsafeUnpin for FinderReverse<'a>`

`impl<'a> UnwindSafe for FinderReverse<'a>`

`impl<T> Any for FinderReverse<'a>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for FinderReverse<'a>`

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

`impl<T> BorrowMut for FinderReverse<'a>`

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

`impl<T> CloneToUninit for FinderReverse<'a>`

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

`impl<T> From for FinderReverse<'a>`

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

`impl<T> ToOwned for FinderReverse<'a>`

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

`impl<T, U> Into for FinderReverse<'a>`

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 FinderReverse<'a>`

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

`impl<T, U> TryInto for FinderReverse<'a>`

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