Struct Matchmaker 

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

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, C>

Implementations

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

pub fn new_from_config( config: Config, matcher_config: MMConfig, ) -> (Self, ConfigInjector, OddEnds)

Creates a new Matchmaker from a config::Config.

impl<T: MMItem, 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_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: MMItem, S: Selection, C> Matchmaker<T, S, C>

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

pub fn get_controller(&self) -> UnboundedSender<Event>

The controller can be used to influence the event loop and by proxy the render loop. However, it’s role is not yet solidified.

pub fn connect_preview(&mut self, preview: Preview)

The contents of the preview are displayed in a pane when picking.

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

Configure keybinds

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

Configure the UI

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

Configure the TUI

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

Configure exit conditions

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

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

Register a handler to listen on Events

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

where I: IntoIterator<Item = 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 EphemeralState<'_, T, S, C>, &Interrupt) + Send + Sync + 'static,

Register a handler to listen on Interrupts

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

Register a boxed handler to listen on Interrupts

pub async fn pick_with_matcher( self, matcher: &mut Matcher, ) -> Result<Vec<S>, MatchError>

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(self) -> Result<Vec<S>, MatchError>

Examples found in repository

examples/basic.rs (line 14)

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

Trait Implementations

impl<T: MMItem + 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.