Struct dia_args::Args

pub struct Args { /* fields omitted */ }

Arguments

Usage

• cmds() can contain commands and normal arguments (such as file paths...)
• sub_args() are not verified. They are the ones after -- symbol, which are meant for being passed to sub processes.

Methods

impl Args

pub fn cmd(&self) -> Option<&str>

Gets the command

pub fn cmds(&self) -> Option<Vec<&str>>

Gets the commands

If it's some vector, the vector is not empty.

pub fn args(&self) -> &HashMap<String, Vec<String>>

Gets raw arguments

pub fn sub_args(&self) -> Option<Vec<&str>>

Sub arguments

If it's some vector, the vector is not empty.

pub fn is_empty(&self) -> bool

Checks if there are no commands/arguments/sub arguments

pub fn has_args(&self) -> bool

Checks if there are arguments or sub arguments

pub fn use_stdin(&self) -> bool

Gets flag for using stdin

pub fn sub_cmd(self) -> (Option<String>, Self)

Transforms into sub command

For example:

• Command line: program help version 1
• First parse: help version 1
• After calling this function: version 1

use dia_args;

const CMD_VERSION: &str = "version";

let (cmd, args) = dia_args::parse()?.sub_cmd();
match cmd.as_ref().map(|s| s.as_str()) {
    Some(CMD_VERSION) => match args.is_empty() {
        true => println!("Version: ..."),
        false => eprintln!("{:?} command doesn't take arguments", CMD_VERSION),
    },
    Some(other) => eprintln!("Command {:?} not supported", other),
    None => eprintln!("Missing command"),
};

pub fn get<T, S>(&self, keys: &[S]) -> Result<Option<T>> where
    T: FromStr,
    S: AsRef<str>, 

Gets a value

You can provide multiple keys as you want. But the user can only provide one single key of them. This function can be used for short version and long version of your keys.

Examples

use dia_args;

let args = dia_args::parse_strings(["--type", "ogg"].iter())?;
assert_eq!(args.get::<String, _>(&["-t", "--type"])?.unwrap(), "ogg");

let args = dia_args::parse_strings(["--type", "ogg"].iter())?;
assert!(args.get::<String, _>(&["-t"])?.is_none());

let args = dia_args::parse_strings(["--type", "ogg", "-t", "some"].iter())?;
args.get::<String, _>(&["-t", "--type"]).unwrap_err();

pub fn take<T, S>(&mut self, keys: &[S]) -> Result<Option<T>> where
    T: FromStr,
    S: AsRef<str>, 

Calls get() and removes the keys if the result is Ok(Some)

Examples

use dia_args;

let mut args = dia_args::parse_strings(["--type", "rs"].iter())?;
assert_eq!(args.take::<String, _>(&["--type"])?.unwrap(), "rs");
assert!(args.get::<String, _>(&["--type"])?.is_none());

pub fn get_vec<T, S>(&self, keys: &[S]) -> Result<Option<Vec<T>>> where
    T: FromStr,
    S: AsRef<str>, 

Gets a vector of values

Examples

use dia_args;

let args = dia_args::parse_strings(
    ["--type", "ogg", "-t", "m4v", "--type", "md", "-t", "rs"].iter()
)?;
let mut types = args.get_vec::<String, _>(&["-t", "--type"])?.unwrap();
types.sort();
assert_eq!(types, &["m4v", "md", "ogg", "rs"]);

pub fn take_vec<T, S>(&mut self, keys: &[S]) -> Result<Option<Vec<T>>> where
    T: FromStr,
    S: AsRef<str>, 

Calls get_vec() and removes the keys if the result is Ok(Some)

Examples

use dia_args;

let mut args = dia_args::parse_strings(["-l", "c", "-l", "c++"].iter())?;
let mut languages = args.take_vec::<String, _>(&["-l"])?.unwrap();
languages.sort();
assert_eq!(languages, &["c", "c++"]);
assert!(args.is_empty());

pub fn take_cmds(&mut self) -> Option<Vec<String>>

Takes commands out

Examples

use dia_args;

let mut args = dia_args::parse_strings(["do", "this", "--faster=true"].iter())?;
assert_eq!(args.take_cmds().unwrap(), &["do", "this"]);

pub fn take_sub_args(&mut self) -> Option<Vec<String>>

Takes sub arguments out

Examples

use dia_args;

let mut args = dia_args::parse_strings(
    ["eat", "chicken", "--", "with", "ronnie-coleman"].iter()
)?;
assert_eq!(args.take_sub_args().unwrap(), &["with", "ronnie-coleman"]);

pub fn merge_args(
    &mut self,
    other: &mut Self,
    merge_option: MergeOption
) -> usize

Merges arguments from other

• This function works on arguments, not commands/stdin flag/sub arguments...
• Other's arguments will be taken out, if conditions are met.
• Result is number of items merged.

Examples

Your program allows the user to set arguments from file. Later you want to give the user new option to set arguments via command line, overwriting the ones from file. This function can help.

use dia_args::MergeOption;

// Here in test, we're parsing from strings.
// In real code, you might want to use dia_args::parse_file()
let mut args_from_file = dia_args::parse_strings(
    ["--debug=false", "--port=6789"].iter()
)?;

// Command line arguments
let mut cmd_line_args = dia_args::parse_strings(
    ["--debug=true", "--address", "localhost"].iter()
)?;

// Merge
assert_eq!(args_from_file.merge_args(&mut cmd_line_args, MergeOption::TakeAll), 2);

assert_eq!(args_from_file.get(&["--debug"])?, Some(true));
assert_eq!(args_from_file.get::<String, _>(&["--address"])?.unwrap(), "localhost");
assert_eq!(args_from_file.get::<u16, _>(&["--port"])?, Some(6789));

Trait Implementations

impl Clone for Args

fn clone(&self) -> Args

Returns a copy of the value.

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

Performs copy-assignment from source.

impl AsRef<Args> for Args

fn as_ref(&self) -> &Self

Performs the conversion.

impl From<Args> for ReadOnlyArgs

fn from(args: Args) -> Self

Performs the conversion.

impl Default for Args

fn default() -> Args

Returns the "default value" for a type.

impl Debug for Args

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

Formats the value using the given formatter.