Struct Worker 

pub struct Worker<T, C = ()>
where
    T: MMItem,
{ /* 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: MMItem,

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 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: MMItem, C> Worker<T, C>

pub fn results( &mut self, start: u32, end: u32, width_limits: &[u16], highlight_style: Style, matcher: &mut Matcher, ) -> (WorkerResults<'_, T>, Vec<u16>, Status)

impl<T: MMItem> Worker<T>

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

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

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

pub fn new_single_column() -> Self

Create a new worker over items which are displayed in the picker as exactly their as_str representation.

Examples found in repository

examples/frecency.rs (line 5)

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

    Ok(())
}

examples/ripgrep.rs (line 5)

fn main() -> Result<()> {
    let worker = Worker::new_single_column();
    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_column();
    worker.append(items);
    let identifier = Indexed::identifier;

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

    match mm.pick().await {
        Ok(v) => {
            println!("{}", v[0]);
        }
        Err(err) => {
            match err {
                MatchError::Abort(1) => {
                    eprintln!("cancelled");
                }
                _ => {
                    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_column();
    let items = vec!["item1", "item2", "item3"];
    worker.append(items);

    Ok(())
}

examples/ripgrep.rs (line 7)

fn main() -> Result<()> {
    let worker = Worker::new_single_column();
    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_column();
    worker.append(items);
    let identifier = Indexed::identifier;

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

    match mm.pick().await {
        Ok(v) => {
            println!("{}", v[0]);
        }
        Err(err) => {
            match err {
                MatchError::Abort(1) => {
                    eprintln!("cancelled");
                }
                _ => {
                    eprintln!("Error: {err}");
                }
            }
        }
    }

    Ok(())
}

impl<T> Worker<T>

where T: ColumnIndexable + MMItem,

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

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

Create a new worker over indexable items, whose columns as displayed in the picker correspond to indices according to the relative order of the column names given to this function.