Struct Atom 

pub struct Atom {
    pub negative: bool,
    pub kind: AtomKind,
    /* private fields */
}

A single pattern component that is matched with a single Matcher function.

Fields

negative: bool

Whether this pattern atom is a negative match. A negative pattern atom will prevent haystacks matching it from being matchend. It does not contribute to scoring/indices

kind: AtomKind

The kind of match that this pattern performs

Implementations

impl Atom

pub fn new( needle: &str, case: CaseMatching, normalize: Normalization, kind: AtomKind, escape_whitespace: bool, ) -> Atom

Creates a single Atom from a string by performing unicode normalization and case folding (if necessary). Optionally \ can be escaped to .

pub fn parse(raw: &str, case: CaseMatching, normalize: Normalization) -> Atom

Parse a pattern atom from a string. Some special trailing and leading characters can be used to control the atom kind. See AtomKind for details.

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

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<u16>

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 vector is not cleared by this function.

pub fn needle_text(&self) -> Utf32Str<'_>

Returns the needle text that is passed to the matcher. All indices produced by the indices functions produce char indices used to index this text

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

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.

Trait Implementations

impl Clone for Atom

fn clone(&self) -> Atom

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Atom

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

Formats the value using the given formatter.

impl PartialEq for Atom

fn eq(&self, other: &Atom) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Atom

impl StructuralPartialEq for Atom