[−][src]Struct dia_args::Args
Arguments
Notes
sub_args()
are not verified. They are the ones after--
phrase, which (often) are meant for being passed to sub processes.
Methods
impl Args
[src]
pub fn cmd(&self) -> Option<&str>
[src]
Gets the command
This is simply the first one of args()
.
pub fn args(&self) -> Option<Vec<&str>>
[src]
Gets arguments
If it's some vector, the vector is not empty.
The first one can be used as a command, via cmd()
.
pub fn options(&self) -> &HashMap<String, Vec<String>>
[src]
Gets raw options
Normally you don't need this. Instead, you can use get()
, get_vec()
...
pub fn sub_args(&self) -> Option<Vec<&str>>
[src]
Sub arguments
If it's some vector, the vector is not empty.
pub fn is_empty(&self) -> bool
[src]
pub fn use_stdin(&self) -> bool
[src]
pub fn into_sub_cmd(self) -> (Option<String>, Self)
[src]
Transforms into sub command
For example:
-
Command line:
~> program help version 1
-
Parsed as:
help version 1
-
After calling this function:
version 1
use dia_args; const CMD_VERSION: &str = "version"; let (cmd, args) = dia_args::parse()?.into_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>(&self, keys: &[&str]) -> Result<Option<T>> where
T: FromStr,
<T as FromStr>::Err: Debug,
[src]
T: FromStr,
<T as FromStr>::Err: Debug,
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>(&mut self, keys: &[&str]) -> Result<Option<T>> where
T: FromStr,
<T as FromStr>::Err: Debug,
[src]
T: FromStr,
<T as FromStr>::Err: Debug,
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>(&self, keys: &[&str]) -> Result<Option<Vec<T>>> where
T: FromStr,
<T as FromStr>::Err: Debug,
[src]
T: FromStr,
<T as FromStr>::Err: Debug,
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>(&mut self, keys: &[&str]) -> Result<Option<Vec<T>>> where
T: FromStr,
<T as FromStr>::Err: Debug,
[src]
T: FromStr,
<T as FromStr>::Err: Debug,
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_args(&mut self) -> Option<Vec<String>>
[src]
Takes arguments out
Examples
use dia_args; let mut args = dia_args::parse_strings(["do", "this", "--faster=true"].iter())?; assert_eq!(args.take_args().unwrap(), &["do", "this"]);
pub fn take_sub_args(&mut self) -> Option<Vec<String>>
[src]
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_options(
&mut self,
other: &mut Self,
filter: &[&[&str]],
merge_option: MergeOption
) -> Result<usize>
[src]
&mut self,
other: &mut Self,
filter: &[&[&str]],
merge_option: MergeOption
) -> Result<usize>
Merges options with other
- This function works on options, not commands/stdin flag/sub arguments...
- Other's options will be taken out, if conditions are met.
- Result is number of items merged.
Parameters
-
filter
:- If you provide some sets of keys, only those (from other) are accepted.
- If you provide an empty slice, or any of its items is empty, an error is returned.
Examples
Your program allows the user to set options from file. Later you want to give the user new ability to set options via command line, overwriting the ones from file. Then this function can help.
use dia_args::MergeOption; const ARG_DEBUG: &[&str] = &["-d", "--debug"]; const ARG_PORT: &[&str] = &["--port"]; // 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( ["-d=true", "--address", "localhost"].iter() )?; // Merge let count = cmd_line_args.merge_options( &mut args_from_file, &[ARG_DEBUG, ARG_PORT], MergeOption::IgnoreExisting, )?; assert_eq!(count, 1); // Verify assert_eq!(cmd_line_args.get(ARG_DEBUG)?, Some(true)); assert_eq!(cmd_line_args.get::<String>(&["--address"])?.unwrap(), "localhost"); assert_eq!(cmd_line_args.get::<u16>(ARG_PORT)?, Some(6789));
Trait Implementations
impl AsRef<Args> for Args
[src]
impl From<Args> for ReadOnlyArgs
[src]
impl Clone for Args
[src]
impl Default for Args
[src]
impl Debug for Args
[src]
Auto Trait Implementations
impl Send for Args
impl Sync for Args
impl Unpin for Args
impl UnwindSafe for Args
impl RefUnwindSafe for Args
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = !
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,