Trait Pattern

pub trait Pattern<'a>: Sized {
    type Searcher: Searcher<'a>;

    // Required method
    fn into_searcher(self, haystack: &'a bstr) -> Self::Searcher;

    // Provided methods
    fn is_contained_in(self, haystack: &'a bstr) -> bool { ... }
    fn is_prefix_of(self, haystack: &'a bstr) -> bool { ... }
    fn is_suffix_of(self, haystack: &'a bstr) -> bool
       where Self::Searcher: ReverseSearcher<'a> { ... }
}

A byte string pattern.

A Pattern<'a> expresses that the implementing type can be used as a byte string pattern for searching in a &'a bstr.

For example, both 'a' and "aa" are patterns that would match at index 1 in the byte string "baaaab".

The trait itself acts as a builder for an associated Searcher type, which does the actual work of finding occurrences of the pattern in a byte string.

Required Associated Types

type Searcher: Searcher<'a>

Associated searcher for this pattern

Required Methods

fn into_searcher(self, haystack: &'a bstr) -> Self::Searcher

Constructs the associated searcher from self and the haystack to search in.

Provided Methods

fn is_contained_in(self, haystack: &'a bstr) -> bool

Checks whether the pattern matches anywhere in the haystack

fn is_prefix_of(self, haystack: &'a bstr) -> bool

Checks whether the pattern matches at the front of the haystack

fn is_suffix_of(self, haystack: &'a bstr) -> bool

where Self::Searcher: ReverseSearcher<'a>,

Checks whether the pattern matches at the back of the haystack

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> Pattern<'a> for u8

Searches for bytes that are equal to a given byte

type Searcher = ByteSearcher<'a>

fn into_searcher(self, haystack: &'a bstr) -> Self::Searcher

fn is_contained_in(self, haystack: &'a bstr) -> bool

fn is_prefix_of(self, haystack: &'a bstr) -> bool

fn is_suffix_of(self, haystack: &'a bstr) -> bool

where Self::Searcher: ReverseSearcher<'a>,

impl<'a, 'b> Pattern<'a> for &'b str

Delegates to the &bstr impl.

type Searcher = StrSearcher<'a, 'b>

fn into_searcher(self, haystack: &'a bstr) -> StrSearcher<'a, 'b>

fn is_contained_in(self, haystack: &'a bstr) -> bool

fn is_prefix_of(self, haystack: &'a bstr) -> bool

fn is_suffix_of(self, haystack: &'a bstr) -> bool

where StrSearcher<'a, 'b>: ReverseSearcher<'a>,

impl<'a, 'b> Pattern<'a> for &'b [u8]

Searches for bytes that are equal to any of the bytes in the array

type Searcher = ByteSliceSearcher<'a, 'b>

fn into_searcher(self, haystack: &'a bstr) -> ByteSliceSearcher<'a, 'b>

fn is_contained_in(self, haystack: &'a bstr) -> bool

fn is_prefix_of(self, haystack: &'a bstr) -> bool

fn is_suffix_of(self, haystack: &'a bstr) -> bool

where ByteSliceSearcher<'a, 'b>: ReverseSearcher<'a>,

impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str

Delegates to the &bstr impl.

type Searcher = StrSearcher<'a, 'b>

fn into_searcher(self, haystack: &'a bstr) -> StrSearcher<'a, 'b>

fn is_contained_in(self, haystack: &'a bstr) -> bool

fn is_prefix_of(self, haystack: &'a bstr) -> bool

fn is_suffix_of(self, haystack: &'a bstr) -> bool

where StrSearcher<'a, 'b>: ReverseSearcher<'a>,

Implementors

impl<'a, 'b> Pattern<'a> for &'b bstr

Non-allocating substring search.

Will handle the pattern "" as returning empty matches at each character boundary.

type Searcher = StrSearcher<'a, 'b>

impl<'a, 'b, 'c> Pattern<'a> for &'c &'b bstr

Delegates to the &bstr impl.

type Searcher = StrSearcher<'a, 'b>

impl<'a, F> Pattern<'a> for F

where F: FnMut(u8) -> bool,

Searches for bytes that match the given predicate

type Searcher = BytePredicateSearcher<'a, F>