Struct Worker 

pub struct Worker<T>
where
    T: SSS,
{ /* private fields */ }

Worker: can instantiate, push, and get results. A view into computation.

Additionally, the worker can affect the computation via find and restart.

Implementations

impl<T: SSS> Worker<T>

pub fn make_format_fn<const QUOTE: bool>( &self, blank_format: impl Fn(&T) -> Cow<'_, str> + SSS, ) -> RenderFn<T>

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

impl<T: Render + SSS> 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/ripgrep.rs (line 5)

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

    Ok(())
}

examples/pick_1.rs (line 7)

pub async fn mm_get<T: SSS + Render + Clone>(
    items: impl IntoIterator<Item = T>,
) -> Result<T, MatchError> {
    let worker = Worker::new_single_column();
    worker.append(items);
    let selector = Selector::new(Indexed::identifier);
    let mm = Matchmaker::new(worker, selector);

    mm.pick_default().await.first()
}

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 selector = Selector::new(Indexed::identifier);
    let mm = Matchmaker::new(worker, selector);

    match mm.pick_default().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/ripgrep.rs (line 7)

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

    Ok(())
}

examples/pick_1.rs (line 8)

pub async fn mm_get<T: SSS + Render + Clone>(
    items: impl IntoIterator<Item = T>,
) -> Result<T, MatchError> {
    let worker = Worker::new_single_column();
    worker.append(items);
    let selector = Selector::new(Indexed::identifier);
    let mm = Matchmaker::new(worker, selector);

    mm.pick_default().await.first()
}

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 selector = Selector::new(Indexed::identifier);
    let mm = Matchmaker::new(worker, selector);

    match mm.pick_default().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 + SSS,

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.

impl<T> Worker<T>

where T: SSS,

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

Column names must be distinct!

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

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: SSS> Worker<T>

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