# Trait bitflags::__core::str::pattern::Pattern [−] [src]

    pub trait Pattern<'a> {
        type Searcher: Searcher<'a>;
        fn into_searcher(self, haystack: &'a str) -> Self::Searcher;

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

Unstable (`pattern`)

: API not fully fleshed out and ready to be stabilized

A string pattern.

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

For example, both `'a'` and `"aa"` are patterns that would match at index `1` in the 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 string.

## Associated Types

### `type Searcher: Searcher<'a>`

Unstable (`pattern`)

: API not fully fleshed out and ready to be stabilized

Associated searcher for this pattern

## Required Methods

### `fn into_searcher(self, haystack: &'a str) -> Self::Searcher`

Unstable (`pattern`)

: API not fully fleshed out and ready to be stabilized

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

## Provided Methods

### `fn is_contained_in(self, haystack: &'a str) -> bool`

Unstable (`pattern`)

: API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches anywhere in the haystack

### `fn is_prefix_of(self, haystack: &'a str) -> bool`

Unstable (`pattern`)

: API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches at the front of the haystack

### `fn is_suffix_of(self, haystack: &'a str) -> bool where Self::Searcher: ReverseSearcher<'a>`

Unstable (`pattern`)

: API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches at the back of the haystack

## Implementors

- `impl<'a> Pattern for char`
- `impl<'a, 'b> Pattern for &'b [char]`
- `impl<'a, F> Pattern for F where F: FnMut(char) -> bool`
- `impl<'a, 'b, 'c> Pattern for &'c &'b str`
- `impl<'a, 'b> Pattern for &'b str`
- `impl<'a, 'b> Pattern for &'b String`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)