Struct clap::builder::BoolishValueParser

#[non_exhaustive]
pub struct BoolishValueParser {}

Parse bool-like string values, everything else is true

See also:

• ValueParser::bool for different human readable bool representations
• FalseyValueParser for assuming non-false is true

Example

Usage:

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("append")
            .value_parser(clap::builder::BoolishValueParser::new())
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "true"]).unwrap();
let port: bool = *m.get_one("append")
    .expect("required");
assert_eq!(port, true);

Semantics:

let value_parser = clap::builder::BoolishValueParser::new();
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("random")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("100")).is_err());
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("true")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("Yes")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("oN")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("1")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("false")).unwrap(), false);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("No")).unwrap(), false);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("oFF")).unwrap(), false);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("0")).unwrap(), false);

Implementations

impl BoolishValueParser

pub fn new() -> Self

Parse bool-like string values, everything else is true

Trait Implementations

impl Clone for BoolishValueParser

fn clone(&self) -> BoolishValueParser

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BoolishValueParser

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

Formats the value using the given formatter.

impl Default for BoolishValueParser

fn default() -> Self

Returns the “default value” for a type.

impl TypedValueParser for BoolishValueParser

type Value = bool

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

impl Copy for BoolishValueParser