Struct Pattern 

#[non_exhaustive]
pub struct Pattern {
    pub atoms: Vec<Atom>,
}

A text pattern made up of (potentially multiple) atoms.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

atoms: Vec<Atom>

The individual pattern (words) in this pattern

Implementations

impl Pattern

pub fn new( pattern: &str, case_matching: CaseMatching, normalize: Normalization, kind: AtomKind, ) -> Pattern

Creates a pattern where each word is matched individually (whitespaces can be escaped with \). Otherwise no parsing is performed (so $, !, ' and ^ don’t receive special treatment). If you want to match the entire pattern as a single needle use a single Atom instead.

pub fn parse( pattern: &str, case_matching: CaseMatching, normalize: Normalization, ) -> Pattern

Creates a pattern where each word is matched individually (whitespaces can be escaped with \). And $, !, ' and ^ at word boundaries will cause different matching behaviour (see AtomKind). These can be escaped with backslash.

pub fn match_list<T>( &self, items: impl IntoIterator<Item = T>, matcher: &mut Matcher, ) -> Vec<(T, u32)>

where T: AsRef<str>,

Convenience function to easily match (and sort) a (relatively small) list of inputs.

Note This function is not recommended for building a full fuzzy matching application that can match large numbers of matches (like all files in a directory) as all matching is done on the current thread, effectively blocking the UI. For such applications the high level nucleo crate can be used instead.

pub fn score( &self, haystack: Utf32Str<'_>, matcher: &mut Matcher, ) -> Option<u32>

Matches this pattern against haystack (using the allocation and configuration from matcher) and calculates a ranking score. See the Matcher documentation for more details.

Note: The ignore_case setting is overwritten to match the casing of each pattern atom.

pub fn indices( &self, haystack: Utf32Str<'_>, matcher: &mut Matcher, indices: &mut Vec<u32>, ) -> Option<u32>

Matches this pattern against haystack (using the allocation and configuration from matcher), calculates a ranking score and the match indices. See the Matcher documentation for more details.

Note: The ignore_case setting is overwritten to match the casing of each pattern atom.

Note: The indices for each pattern are calculated individually and simply appended to the indices vector and not deduplicated/sorted. This allows associating the match indices to their source pattern. If required (like for highlighting) unique/sorted indices can be obtained as follows:

indices.sort_unstable();
indices.dedup();

pub fn reparse( &mut self, pattern: &str, case_matching: CaseMatching, normalize: Normalization, )

Refreshes this pattern by reparsing it from a string. This is mostly equivalent to just constructing a new pattern using Pattern::parse but is slightly more efficient by reusing some allocations

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Pattern)

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.

impl Default for Pattern

fn default() -> Pattern

Returns the “default value” for a type.