Struct clap::builder::EnumValueParser

pub struct EnumValueParser<E: ValueEnum + Clone + Send + Sync + 'static>(/* private fields */);

Parse an ValueEnum value.

See also:

• PossibleValuesParser

Example

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
enum ColorChoice {
    Always,
    Auto,
    Never,
}

impl clap::ValueEnum for ColorChoice {
    fn value_variants<'a>() -> &'a [Self] {
        &[Self::Always, Self::Auto, Self::Never]
    }

    fn to_possible_value<'a>(&self) -> Option<clap::PossibleValue<'a>> {
        match self {
            Self::Always => Some(clap::PossibleValue::new("always")),
            Self::Auto => Some(clap::PossibleValue::new("auto")),
            Self::Never => Some(clap::PossibleValue::new("never")),
        }
    }
}

// Usage
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("color")
            .value_parser(clap::builder::EnumValueParser::<ColorChoice>::new())
            .required(true)
    );

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

// Semantics
let value_parser = clap::builder::EnumValueParser::<ColorChoice>::new();
// or
let value_parser = clap::value_parser!(ColorChoice);
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(), ColorChoice::Always);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("auto")).unwrap(), ColorChoice::Auto);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("never")).unwrap(), ColorChoice::Never);

Implementations

impl<E: ValueEnum + Clone + Send + Sync + 'static> EnumValueParser<E>

pub fn new() -> Self

Parse an ValueEnum

Trait Implementations

impl<E: Clone + ValueEnum + Clone + Send + Sync + 'static> Clone for EnumValueParser<E>

fn clone(&self) -> EnumValueParser<E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Debug + ValueEnum + Clone + Send + Sync + 'static> Debug for EnumValueParser<E>

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

Formats the value using the given formatter.

impl<E: ValueEnum + Clone + Send + Sync + 'static> Default for EnumValueParser<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E: ValueEnum + Clone + Send + Sync + 'static> TypedValueParser for EnumValueParser<E>

type Value = E

Argument’s value type

fn parse_ref( &self, cmd: &Command<'_>, arg: Option<&Arg<'_>>, value: &OsStr ) -> Result<Self::Value, Error>

Parse the argument value

fn possible_values( &self ) -> Option<Box<dyn Iterator<Item = PossibleValue<'static>> + '_>>

Reflect on enumerated value properties

fn parse( &self, cmd: &Command<'_>, arg: Option<&Arg<'_>>, value: OsString ) -> Result<Self::Value, Error>

Parse the argument value

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