Struct Worker 

pub struct Worker<T, C = ()>
where
    T: PickerItem,
{ /* private fields */ }

Worker: can instantiate, can push, can get lines and get nth, a view into computation

Implementations

impl<T, C> Worker<T, C>

where T: PickerItem,

pub fn new( columns: impl IntoIterator<Item = Column<T, C>>, default_column: usize, context: C, ) -> Self

pub fn injector(&self) -> WorkerInjector<T, C>

pub fn results( &mut self, start: u32, end: u32, matcher: &mut Matcher, ) -> (Vec<(Vec<Text<'_>>, &T, u16)>, Vec<u16>, Status)

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

pub fn shutdown(&mut self)

pub fn restart(&mut self, clear_snapshot: bool)

pub fn get_nth(&self, n: u32) -> Option<&T>

pub fn new_snapshot(nucleo: &mut Nucleo<T>) -> (&Snapshot<T>, Status)

pub fn raw_results( &self, ) -> impl ExactSizeIterator<Item = &T> + DoubleEndedIterator + '_

pub fn counts(&self) -> (u32, u32)

matched item count, total item count

impl<T: PickerItem> Worker<T>

pub fn make_format_fn<const QUOTE: bool>( &self, blank_format: impl Fn(&T) -> &str + Send + Sync + 'static, ) -> Box<dyn Fn(&T, &str) -> String + Send + Sync>

Returns a function which templates a string given an item using the column functions

impl<T: Render + PickerItem> Worker<Indexed<T>>

pub fn new_single() -> Self

Examples found in repository

examples/frecency.rs (line 5)

fn main() -> Result<()> {
    let worker = Worker::new_single();
    let items = vec!["item1", "item2", "item3"];
    worker.append(items);

    Ok(())
}

examples/ripgrep.rs (line 5)

fn main() -> Result<()> {
    let worker = Worker::new_single();
    let items = vec!["item1", "item2", "item3"];
    worker.append(items);

    Ok(())
}

examples/basic.rs (line 8)

async fn main() -> Result<()> {
    let items = vec!["item1", "item2", "item3"];

    let worker = Worker::new_single();
    worker.append(items);
    let identifier = Worker::clone_identifier;

    let mm = Matchmaker::new(worker, identifier);

    match mm.pick().await {
        Ok(iter) => {
            for s in iter {
                println!("{s}");
            }
        }
        Err(err) => {
            if let Some(e) = err.downcast_ref::<MatchmakerError>()
                && matches!(e, MatchmakerError::Abort(1))
            {
                eprintln!("cancelled");
            } else {
                eprintln!("Error: {err}");
            }
        }
    }

    Ok(())
}

pub fn append(&self, items: impl IntoIterator<Item = T>) -> u32

A convenience method to initialize data. Note that it is clearly unsound to use this concurrently with other workers, or to subsequently push with an IndexedInjector.

Examples found in repository

examples/frecency.rs (line 7)

fn main() -> Result<()> {
    let worker = Worker::new_single();
    let items = vec!["item1", "item2", "item3"];
    worker.append(items);

    Ok(())
}

examples/ripgrep.rs (line 7)

fn main() -> Result<()> {
    let worker = Worker::new_single();
    let items = vec!["item1", "item2", "item3"];
    worker.append(items);

    Ok(())
}

examples/basic.rs (line 9)

async fn main() -> Result<()> {
    let items = vec!["item1", "item2", "item3"];

    let worker = Worker::new_single();
    worker.append(items);
    let identifier = Worker::clone_identifier;

    let mm = Matchmaker::new(worker, identifier);

    match mm.pick().await {
        Ok(iter) => {
            for s in iter {
                println!("{s}");
            }
        }
        Err(err) => {
            if let Some(e) = err.downcast_ref::<MatchmakerError>()
                && matches!(e, MatchmakerError::Abort(1))
            {
                eprintln!("cancelled");
            } else {
                eprintln!("Error: {err}");
            }
        }
    }

    Ok(())
}

pub fn clone_identifier(item: &Indexed<T>) -> (u32, T)

where T: Clone,

impl<T> Worker<T>

where T: ColumnIndexable + PickerItem,

pub fn new_indexable<I, S>(column_names: I) -> Self

where I: IntoIterator<Item = S>, S: Into<Arc<str>>,