Struct nucleo_matcher::pattern::Pattern
source · #[non_exhaustive]pub struct Pattern {
pub atoms: Vec<Atom>,
}
Expand description
A text pattern made up of (potentially multiple) atoms.
Fields (Non-exhaustive)§
This struct is marked as non-exhaustive
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§
source§impl Pattern
impl Pattern
sourcepub fn new(
pattern: &str,
case_matching: CaseMatching,
normalize: Normalization,
kind: AtomKind
) -> 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.
sourcepub fn parse(
pattern: &str,
case_matching: CaseMatching,
normalize: Normalization
) -> Pattern
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.
sourcepub fn match_list<T: AsRef<str>>(
&self,
items: impl IntoIterator<Item = T>,
matcher: &mut Matcher
) -> Vec<(T, u32)>
pub fn match_list<T: AsRef<str>>( &self, items: impl IntoIterator<Item = T>, matcher: &mut Matcher ) -> Vec<(T, u32)>
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.
sourcepub fn score(
&self,
haystack: Utf32Str<'_>,
matcher: &mut Matcher
) -> Option<u32>
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.
sourcepub fn indices(
&self,
haystack: Utf32Str<'_>,
matcher: &mut Matcher,
indices: &mut Vec<u32>
) -> Option<u32>
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();
sourcepub fn reparse(
&mut self,
pattern: &str,
case_matching: CaseMatching,
normalize: Normalization
)
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