Struct MultiSelect 

pub struct MultiSelect<'a, T> {
    pub title: String,
    pub theme: &'a Theme,
    pub description: String,
    pub options: Vec<DemandOption<T>>,
    pub min: usize,
    pub max: usize,
    pub filterable: bool,
    pub filtering: bool,
    pub filter: String,
    /* private fields */
}

Select multiple options from a list

Example

use demand::{DemandOption, MultiSelect};

let multiselect = MultiSelect::new("Toppings")
  .description("Select your toppings")
  .min(1)
  .max(4)
  .filterable(true)
  .option(DemandOption::new("Lettuce").selected(true))
  .option(DemandOption::new("Tomatoes").selected(true))
  .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 toppings = match multiselect.run() {
  Ok(toppings) => toppings,
  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 after the title

options: Vec<DemandOption<T>>

The options which can be selected

min: usize

The minimum number of options which must be selected

max: usize

The maximum number of options which can be selected

filterable: bool

Whether the selector can be filtered with a query

filtering: bool

Whether the selector is currently being filtered

filter: String

A filter query to preset when filtering is true

Implementations

impl<'a, T> MultiSelect<'a, T>

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

Create a new multi 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 min(self, min: usize) -> Self

Set the minimum number of options which must be selected

pub fn max(self, max: usize) -> Self

Set the maximum number of options which can be selected

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

Set whether the selector can be filtered with a query

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

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

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

Set the theme of the selector

pub fn run(self) -> Result<Vec<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.