Struct Matcher

pub struct Matcher<I>
where
    I: Sync + Send + Clone + 'static,
{
    pub total_item_count: u32,
    pub matched_item_count: u32,
    pub status: Status,
    pub last_pattern: String,
    /* private fields */
}

A fuzzy matcher that can be used to match items of type I.

I should be Sync, Send, Clone, and 'static. This is a wrapper around the Nucleo fuzzy matcher that only matches on a single dimension.

The matcher can be used to find items that match a given pattern and to retrieve the matched items as well as the indices of the matched characters.

Fields

total_item_count: u32

The current total number of items in the matcher.

matched_item_count: u32

The current number of matched items in the matcher.

status: Status

The current status of the matcher.

last_pattern: String

The last pattern that was matched against.

Implementations

impl<I> Matcher<I>

where I: Sync + Send + Clone + 'static,

pub fn new(config: Config) -> Self

Create a new fuzzy matcher with the given configuration.

pub fn tick(&mut self)

Tick the fuzzy matcher.

This should be called periodically to update the state of the matcher.

pub fn injector(&self) -> Injector<I>

Get an injector that can be used to push items into the fuzzy matcher.

This can be used at any time to push items into the fuzzy matcher.

Example

use television_fuzzy::matcher::{config::Config, Matcher};

let config = Config::default();
let matcher = Matcher::new(config);
let injector = matcher.injector();

injector.push(
    ("some string", 3, "some other string"),
    // Say we want to match against the third element of the tuple
    |s, cols| cols[0] = s.2.into()
);

pub fn find(&mut self, pattern: &str)

Find items that match the given pattern.

This should be called whenever the pattern changes. The Matcher will keep track of the last pattern and only reparse the pattern if it has changed, allowing for more efficient matching when self.last_pattern is a prefix of the new pattern.

pub fn results(&mut self, num_entries: u32, offset: u32) -> Vec<MatchedItem<I>>

Get the matched items.

This should be called to retrieve the matched items after calling find.

The num_entries parameter specifies the number of entries to return, and the offset parameter specifies the offset of the first entry to return.

The returned items are MatchedItems that contain the matched item, the dimension against which it was matched, represented as a string, and the indices of the matched characters.

Example

use television_fuzzy::matcher::{config::Config, Matcher};

let config = Config::default();
let mut matcher: Matcher<String> = Matcher::new(config);
matcher.find("some pattern");

let results = matcher.results(10, 0);
for item in results {
    println!("{:?}", item);
    // Do something with the matched item
    // ...
    // Do something with the matched indices
    // ...
}

pub fn get_result(&self, index: u32) -> Option<MatchedItem<I>>

Get a single matched item.

Example

use television_fuzzy::matcher::{config::Config, Matcher};

let config = Config::default();
let mut matcher: Matcher<String> = Matcher::new(config);
matcher.find("some pattern");

if let Some(item) = matcher.get_result(0) {
    // Do something with the matched item
    // ...
}