Struct Select

pub struct Select<'a, T> {
    pub title: String,
    pub theme: &'a Theme,
    pub description: String,
    pub options: Vec<DemandOption<T>>,
    pub filterable: bool,
    /* private fields */
}

Select multiple options from a list

Example

use demand::{DemandOption, Select};

let select = Select::new("Toppings")
  .description("Select your topping")
  .filterable(true)
  .option(DemandOption::new("Lettuce"))
  .option(DemandOption::new("Tomatoes"))
  .option(DemandOption::new("Charm Sauce"))
  .option(DemandOption::new("Jalapenos").label("Jalapeños"))
  .option(DemandOption::new("Cheese"))
  .option(DemandOption::new("Vegan Cheese"))
  .option(DemandOption::new("Nutella"));
let topping = match select.run() {
    Ok(value) => value,
    Err(e) => {
        if e.kind() == std::io::ErrorKind::Interrupted {
            println!("Input cancelled");
            return;
        } else {
            panic!("Error: {}", e);
        }
    }
};

Fields

title: String

The title of the selector

theme: &'a Theme

The colors/style of the selector

description: String

A description to display above the selector

options: Vec<DemandOption<T>>

The options which can be selected

filterable: bool

Whether the selector can be filtered with a query

Implementations

impl<'a, T> Select<'a, T>

pub fn new<S: Into<String>>(title: S) -> Self

Create a new select with the given title

pub fn description(self, description: &str) -> Self

Set the description of the selector

pub fn option(self, option: DemandOption<T>) -> Self

Add an option to the selector

pub fn options(self, options: Vec<DemandOption<T>>) -> Self

Add multiple options to the selector

pub fn filterable(self, filterable: bool) -> Self

Set whether the selector can be filtered with a query

pub fn filtering(self, filtering: bool) -> Self

Start filtering immediately

pub fn theme(self, theme: &'a Theme) -> Self

Set the theme of the selector

pub fn run(self) -> Result<T>

Displays the selector to the user and returns their selected options

This function will block until the user submits the input. If the user cancels the input, an error of type io::ErrorKind::Interrupted is returned.