Struct flaggy::Values

pub struct Values { /* fields omitted */ }

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.

Methods

impl Values

pub fn new(
    default_values: HashMap<String, Value, RandomState>,
    values: HashMap<String, Value, RandomState>
) -> 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 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 Eq for Values

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

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

Performs the conversion.

impl PartialEq<Values> for Values

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

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

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

This method tests for !=.

impl Debug for Values

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

Formats the value using the given formatter.