Struct Matchmaker 

pub struct Matchmaker<T: SSS, S: Selection = T> {
    pub worker: Worker<T>,
    pub render_config: RenderConfig,
    pub tui_config: TerminalConfig,
    pub exit_config: ExitConfig,
    pub selector: Selector<T, S>,
    pub event_handlers: EventHandlers<T, S>,
    pub interrupt_handlers: InterruptHandlers<T, S>,
}

The main entrypoint of the library. To use:

1. create your worker (T -> Columns)
2. Determine your identifier
3. Instantiate this with Matchmaker::new_from_raw(..)
4. Register your handlers 4.5 Start and connect your previewer
5. Call mm.pick() or mm.pick_with_matcher(&mut matcher)

Fields

worker: Worker<T>

render_config: RenderConfig

tui_config: TerminalConfig

exit_config: ExitConfig

selector: Selector<T, S>

event_handlers: EventHandlers<T, S>

interrupt_handlers: InterruptHandlers<T, S>

Implementations

impl Matchmaker<Indexed<Segmented<Either<String, Text<'static>>>>, Segmented<Either<String, Text<'static>>>>

pub fn new_from_config( render_config: RenderConfig, tui_config: TerminalConfig, worker_config: WorkerConfig, exit_config: ExitConfig, ) -> (Self, ConfigInjector, OddEnds)

Creates a new Matchmaker from a config::BaseConfig.

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

pub fn new(worker: Worker<T>, selector: Selector<T, S>) -> Self

Examples found in repository

examples/pick_1.rs (line 8)

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

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

examples/basic.rs (line 11)

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 config_render(&mut self, render: RenderConfig) -> &mut Self

Configure the UI

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

Configure the TUI

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

Configure exit conditions

pub fn register_event_handler<F>(&mut self, event: Event, handler: F)

where F: Fn(&mut MMState<'_, '_, T, S>, &Event) + 'static,

Register a handler to listen on Events

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

Register a boxed handler to listen on Events

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

where F: Fn(&mut MMState<'_, '_, T, S>) + 'static,

Register a handler to listen on Interrupts

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

Register a boxed handler to listen on Interrupts

pub async fn pick<A: ActionExt>( self, builder: PickOptions<'_, T, S, A>, ) -> Result<Vec<S>>

The main method of the Matchmaker. It starts listening for events and renders the TUI with ratatui. It successfully returns with all the selected items selected when the Accept action is received.

pub async fn pick_default(self) -> Result<Vec<S>>

Examples found in repository

examples/pick_1.rs (line 10)

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

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

examples/basic.rs (line 13)

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: SSS, S: Selection> Matchmaker<T, S>

pub fn register_print_handler( &mut self, print_handle: AppendOnly<String>, output_separator: String, formatter: Arc<RenderFn<T>>, )

Causes Action::Print to print to stdout.

pub fn register_execute_handler(&mut self, formatter: Arc<RenderFn<T>>)

Causes Action::Execute to cause the program to execute the program specified by its payload. Note:

• not intended for direct use.
• Assumes preview and cmd formatter are the same.

pub fn register_become_handler(&mut self, formatter: Arc<RenderFn<T>>)

Causes Action::Become to cause the program to become the program specified by its payload. Note:

• not intended for direct use.
• Assumes preview and cmd formatter are the same.

Trait Implementations

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

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

Formats the value using the given formatter.