Struct Values 

pub struct Values { /* private fields */ }

Values is a structure which contains all of the parsed command-line flag values (or the default values for those flags). If parsing fails (including if some required flags weren’t specified, for example), an error is returned.

This structure provides various accessor functions, to conveniently get at the flag values. These accessors tend to follow the pattern of assuming the caller is doing things correctly, and that the caller wants us to panic early if something goes wrong. If this is not the desired behavior, the Values::get accessor provides a safe API where the caller can do their own error handling.

Implementations

impl Values

pub fn new( default_values: HashMap<String, Value>, values: HashMap<String, Value>, ) -> Values

Construct a new Values structure using the given default values, and the given values parsed from the program’s command-line flags.

pub fn contains_key(&self, name: &str) -> bool

Returns whether or not there exists a Value for the given flag.

pub fn get(&self, name: &str) -> Vec<&str>

Return the Value(s) of a single flag, as strings. The returned vector might be empty (if there is no Value associated with the flag), or it might contain exactly one entry (in the case of named or boolean flags), or it might contain many entries (in the case of positional flags).

pub fn get_as<E, T>(&self, name: &str) -> Result<Vec<T>, E>

where T: FromStr<Err = E>,

Return the Value(s) of a single flag, parsed into the given type. This is a convenience wrapper around get.

Trait Implementations

impl Debug for Values

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

Formats the value using the given formatter.

impl From<HashMap<String, Value>> for Values

fn from(values: HashMap<String, Value>) -> Values

Converts to this type from the input type.

impl FromIterator<(String, Value)> for Values

fn from_iter<T>(iter: T) -> Values

where T: IntoIterator<Item = (String, Value)>,

Creates a value from an iterator.

impl PartialEq for Values

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Values

impl StructuralPartialEq for Values