# Struct clap::builder::PossibleValue

source · [−]

    pub struct PossibleValue { /* private fields */ }

Expand description

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

source

### impl PossibleValue

source

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

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")

source

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

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")

source

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

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)

source

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

Sets a hidden alias for this argument value.

##### Examples

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

source

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

Sets multiple hidden aliases for this argument value.

##### Examples

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

source

### impl PossibleValue

Reflection

source

#### pub fn get_name(&self) -> &str

Get the name of the argument value

source

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

Get the help specified for this argument, if any

source

#### pub fn is_hide_set(&self) -> bool

Report if `PossibleValue::hide` is set

source

#### 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.

source

#### 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

source

### impl Clone for PossibleValue

source

#### fn clone(&self) -> PossibleValue

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

### impl Debug for PossibleValue

source

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

Formats the value using the given formatter. Read more

source

### impl Default for PossibleValue

source

#### fn default() -> PossibleValue

Returns the “default value” for a type. Read more

source

### impl<S: Into<Str>> From<S> for PossibleValue

source

#### fn from(s: S) -> Self

Converts to this type from the input type.

source

### impl PartialEq<PossibleValue> for PossibleValue

source

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

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

source

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

This method tests for `!=`.

source

### impl Eq for PossibleValue

source

### impl StructuralEq for PossibleValue

source

### impl StructuralPartialEq for PossibleValue

## Auto Trait Implementations

### impl RefUnwindSafe for PossibleValue

### impl Send for PossibleValue

### impl Sync for PossibleValue

### impl Unpin for PossibleValue

### impl UnwindSafe for PossibleValue

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.