Struct clap::builder::PossibleValue

pub struct PossibleValue { /* private fields */ }

A possible value of an argument.

This is used for specifying possible values of Args.

See also PossibleValuesParser

NOTE: Most likely you can use strings, rather than PossibleValue as it is only required to hide single values from help messages and shell completions or to attach help to possible values.

Examples

let cfg = Arg::new("config")
    .action(ArgAction::Set)
    .value_name("FILE")
    .value_parser([
        PossibleValue::new("fast"),
        PossibleValue::new("slow").help("slower than fast"),
        PossibleValue::new("secret speed").hide(true)
    ]);

Implementations

impl PossibleValue

pub fn new(name: impl Into<Str>) -> PossibleValue

Create a PossibleValue with its name.

The name will be used to decide whether this value was provided by the user to an argument.

NOTE: In case it is not hidden it will also be shown in help messages for arguments that use it as a possible value and have not hidden them through Arg::hide_possible_values(true).

Examples

PossibleValue::new("fast")

pub fn help(self, help: impl IntoResettable<StyledStr>) -> PossibleValue

Sets the help description of the value.

This is typically displayed in completions (where supported) and should be a short, one-line description.

Examples

PossibleValue::new("slow")
    .help("not fast")

pub fn hide(self, yes: bool) -> PossibleValue

Hides this value from help and shell completions.

This is an alternative to hiding through Arg::hide_possible_values(true), if you only want to hide some values.

Examples

PossibleValue::new("secret")
    .hide(true)

pub fn alias(self, name: impl IntoResettable<Str>) -> PossibleValue

Sets a hidden alias for this argument value.

Examples

PossibleValue::new("slow")
    .alias("not-fast")

pub fn aliases( self, names: impl IntoIterator<Item = impl Into<Str>>, ) -> PossibleValue

Sets multiple hidden aliases for this argument value.

Examples

PossibleValue::new("slow")
    .aliases(["not-fast", "snake-like"])

impl PossibleValue

Reflection

pub fn get_name(&self) -> &str

Get the name of the argument value

pub fn get_help(&self) -> Option<&StyledStr>

Get the help specified for this argument, if any

pub fn is_hide_set(&self) -> bool

Report if PossibleValue::hide is set

pub fn get_name_and_aliases(&self) -> impl Iterator<Item = &str>

Returns all valid values of the argument value.

Namely the name and all aliases.

pub fn matches(&self, value: &str, ignore_case: bool) -> bool

Tests if the value is valid for this argument value

The value is valid if it is either the name or one of the aliases.

Examples

let arg_value = PossibleValue::new("fast").alias("not-slow");

assert!(arg_value.matches("fast", false));
assert!(arg_value.matches("not-slow", false));

assert!(arg_value.matches("FAST", true));
assert!(!arg_value.matches("FAST", false));

Trait Implementations

impl Clone for PossibleValue

fn clone(&self) -> PossibleValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PossibleValue

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

Formats the value using the given formatter.

impl Default for PossibleValue

fn default() -> PossibleValue

Returns the “default value” for a type.

impl<S> From<S> for PossibleValue

where S: Into<Str>,

fn from(s: S) -> PossibleValue

Converts to this type from the input type.

impl PartialEq for PossibleValue

fn eq(&self, other: &PossibleValue) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for PossibleValue

impl StructuralPartialEq for PossibleValue