Struct Matchmaker 

pub struct Matchmaker<T: PickerItem, S: Selection = T, C = ()> {
    pub matcher: Option<Matcher>,
    pub worker: Worker<T, C>,
    /* private fields */
}

Fields

matcher: Option<Matcher>

worker: Worker<T, C>

Implementations

impl Matchmaker<Indexed<Segmented<String>>, Segmented<String>>

pub fn new_from_config( config: Config, ) -> (Self, SegmentedInjector<String, IndexedInjector<Segmented<String>, WorkerInjector<Indexed<Segmented<String>>>>>, MiscData)

impl<T: PickerItem, S: Selection> Matchmaker<T, S>

pub fn new(worker: Worker<T>, identifier: fn(&T) -> (u32, S)) -> Self

Examples found in repository

examples/basic.rs (line 12)

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(())
}

impl<T: PickerItem, S: Selection, C> Matchmaker<T, S, C>

pub fn new_raw( worker: Worker<T, C>, identifier: fn(&T) -> (u32, S), context: Arc<C>, ) -> Self

For library use:

1. create your worker (T -> Columns)
2. instantiate a matcher (i.e. globally with lazylock)
3. Determine your identifier
4. Call mm.pick_with_matcher(&mut matcher)

pub fn config_binds(&mut self, bind_config: BindMap) -> &mut Self

pub fn config_render(&mut self, render_config: RenderConfig) -> &mut Self

pub fn config_preview( &mut self, preview_config: PreviewerConfig, ) -> Sender<PreviewMessage>

pub fn config_tui(&mut self, tui_config: TerminalConfig) -> &mut Self

pub fn config_exit(&mut self, exit_config: ExitConfig) -> &mut Self

pub fn register_event_handler<F, I>(&mut self, events: I, handler: F)

where F: Fn(EphemeralState<'_, T, S, C>, &Event) + Send + Sync + 'static, I: IntoIterator<Item = Event>,

pub fn register_boxed_event_handler<I>( &mut self, events: I, handler: DynamicMethod<T, S, C, Event>, )

where I: IntoIterator<Item = Event>,

pub fn register_interrupt_handler<F>( &mut self, interrupt: Interrupt, handler: F, )

where F: Fn(EphemeralState<'_, T, S, C>, &Interrupt) + Send + Sync + 'static,

pub fn register_boxed_interrupt_handler( &mut self, variant: Interrupt, handler: DynamicMethod<T, S, C, Interrupt>, )

pub async fn pick(self) -> Result<impl IntoIterator<Item = S>>

Examples found in repository

examples/basic.rs (line 14)

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 async fn pick_with_matcher( self, matcher: &mut Matcher, ) -> Result<impl IntoIterator<Item = S>>

Trait Implementations

impl<T: PickerItem + Debug, S: Selection + Debug, C: Debug> Debug for Matchmaker<T, S, C>

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

Formats the value using the given formatter.