Struct pretty_exec::clap::builder::PossibleValuesParser

pub struct PossibleValuesParser(_);

Verify the value is from an enumerated set of PossibleValue.

See also:

• EnumValueParser for directly supporting enums
• TypedValueParser::map for adapting values to a more specialized type

Example

Usage:

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("color")
            .value_parser(clap::builder::PossibleValuesParser::new(["always", "auto", "never"]))
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "always"]).unwrap();
let port: &String = m.get_one("color")
    .expect("required");
assert_eq!(port, "always");

Semantics:

let value_parser = clap::builder::PossibleValuesParser::new(["always", "auto", "never"]);
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("random")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("")).is_err());
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("always")).unwrap(), "always");
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("auto")).unwrap(), "auto");
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("never")).unwrap(), "never");

Implementations

impl PossibleValuesParser

pub fn new(values: impl Into<PossibleValuesParser>) -> PossibleValuesParser

Verify the value is from an enumerated set pf PossibleValue.

Trait Implementations

impl Clone for PossibleValuesParser

fn clone(&self) -> PossibleValuesParser

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PossibleValuesParser

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

Formats the value using the given formatter.

impl<I, T> From<I> for PossibleValuesParserwhere
    I: IntoIterator<Item = T>,
    T: Into<PossibleValue>,

fn from(values: I) -> PossibleValuesParser

Converts to this type from the input type.

impl TypedValueParser for PossibleValuesParser

type Value = String

Argument’s value type

fn parse_ref(
    &self,
    cmd: &Command,
    arg: Option<&Arg>,
    value: &OsStr
) -> Result<<PossibleValuesParser as TypedValueParser>::Value, Error<RichFormatter>>

Parse the argument value

fn parse(
    &self,
    cmd: &Command,
    arg: Option<&Arg>,
    value: OsString
) -> Result<String, Error<RichFormatter>>

Parse the argument value

fn possible_values(
    &self
) -> Option<Box<dyn Iterator<Item = PossibleValue>, Global>>

Reflect on enumerated value properties

fn map<T, F>(self, func: F) -> MapValueParser<Self, F>where
    T: Send + Sync + Clone,
    F: Fn(Self::Value) -> T + Clone,

Adapt a TypedValueParser from one value to another

fn try_map<T, E, F>(self, func: F) -> TryMapValueParser<Self, F>where
    F: 'static + Fn(Self::Value) -> Result<T, E> + Clone + Send + Sync,
    T: Send + Sync + Clone,
    E: Into<Box<dyn Error + Send + Sync + 'static, Global>>,

Adapt a TypedValueParser from one value to another