Struct clap::ArgMatches
source · [−]pub struct ArgMatches { /* private fields */ }
Expand description
Container for parse results.
Used to get information about the arguments that were supplied to the program at runtime by
the user. New instances of this struct are obtained by using the Command::get_matches
family of
methods.
Examples
let matches = Command::new("MyApp")
.arg(Arg::new("out")
.long("output")
.required(true)
.takes_value(true))
.arg(Arg::new("debug")
.short('d')
.multiple_occurrences(true))
.arg(Arg::new("cfg")
.short('c')
.takes_value(true))
.get_matches(); // builds the instance of ArgMatches
// to get information about the "cfg" argument we created, such as the value supplied we use
// various ArgMatches methods, such as ArgMatches::value_of
if let Some(c) = matches.value_of("cfg") {
println!("Value for -c: {}", c);
}
// The ArgMatches::value_of method returns an Option because the user may not have supplied
// that argument at runtime. But if we specified that the argument was "required" as we did
// with the "out" argument, we can safely unwrap because `clap` verifies that was actually
// used at runtime.
println!("Value for --output: {}", matches.value_of("out").unwrap());
// You can check the presence of an argument
if matches.is_present("out") {
// Another way to check if an argument was present, or if it occurred multiple times is to
// use occurrences_of() which returns 0 if an argument isn't found at runtime, or the
// number of times that it occurred, if it was. To allow an argument to appear more than
// once, you must use the .multiple_occurrences(true) method, otherwise it will only return 1 or 0.
if matches.occurrences_of("debug") > 2 {
println!("Debug mode is REALLY on, don't be crazy");
} else {
println!("Debug mode kind of on");
}
}
Implementations
sourceimpl ArgMatches
impl ArgMatches
sourcepub fn args_present(&self) -> bool
pub fn args_present(&self) -> bool
Check if any args were present on the command line
Examples
let mut cmd = Command::new("myapp")
.arg(Arg::new("output")
.takes_value(true));
let m = cmd
.try_get_matches_from_mut(vec!["myapp", "something"])
.unwrap();
assert!(m.args_present());
let m = cmd
.try_get_matches_from_mut(vec!["myapp"])
.unwrap();
assert!(! m.args_present());
sourcepub fn value_of<T: Key>(&self, id: T) -> Option<&str>
pub fn value_of<T: Key>(&self, id: T) -> Option<&str>
Gets the value of a specific option or positional argument.
i.e. an argument that takes an additional value at runtime.
Returns None
if the option wasn’t present.
NOTE: Prefer ArgMatches::values_of
if getting a value for an option or positional
argument that allows multiples as ArgMatches::value_of
will only return the first
value.
NOTE: This will always return Some(value)
if default_value
has been set.
occurrences_of
can be used to check if a value is present at runtime.
Panics
If the value is invalid UTF-8. See
Arg::allow_invalid_utf8
.
If id
is is not a valid argument or group name.
Examples
let m = Command::new("myapp")
.arg(Arg::new("output")
.takes_value(true))
.get_matches_from(vec!["myapp", "something"]);
assert_eq!(m.value_of("output"), Some("something"));
sourcepub fn value_of_lossy<T: Key>(&self, id: T) -> Option<Cow<'_, str>>
pub fn value_of_lossy<T: Key>(&self, id: T) -> Option<Cow<'_, str>>
Gets the lossy value of a specific option or positional argument.
i.e. an argument that takes an additional value at runtime.
A lossy value is one which contains invalid UTF-8, those invalid points will be replaced
with \u{FFFD}
Returns None
if the option wasn’t present.
NOTE: Recommend having set Arg::allow_invalid_utf8
.
NOTE: Prefer ArgMatches::values_of_lossy
if getting a value for an option or positional
argument that allows multiples as ArgMatches::value_of_lossy
will only return the first
value.
NOTE: This will always return Some(value)
if default_value
has been set.
occurrences_of
can be used to check if a value is present at runtime.
Panics
If id
is is not a valid argument or group name.
Examples
use std::ffi::OsString;
use std::os::unix::ffi::{OsStrExt,OsStringExt};
let m = Command::new("utf8")
.arg(arg!(<arg> "some arg")
.allow_invalid_utf8(true))
.get_matches_from(vec![OsString::from("myprog"),
// "Hi {0xe9}!"
OsString::from_vec(vec![b'H', b'i', b' ', 0xe9, b'!'])]);
assert_eq!(&*m.value_of_lossy("arg").unwrap(), "Hi \u{FFFD}!");
sourcepub fn value_of_os<T: Key>(&self, id: T) -> Option<&OsStr>
pub fn value_of_os<T: Key>(&self, id: T) -> Option<&OsStr>
Get the OsStr
value of a specific option or positional argument.
i.e. an argument that takes an additional value at runtime.
An OsStr
on Unix-like systems is any series of bytes, regardless of whether or not they
contain valid UTF-8. Since String
s in Rust are guaranteed to be valid UTF-8, a valid
filename on a Unix system as an argument value may contain invalid UTF-8.
Returns None
if the option wasn’t present.
NOTE: Recommend having set Arg::allow_invalid_utf8
.
NOTE: Prefer ArgMatches::values_of_os
if getting a value for an option or positional
argument that allows multiples as ArgMatches::value_of_os
will only return the first
value.
NOTE: This will always return Some(value)
if default_value
has been set.
occurrences_of
can be used to check if a value is present at runtime.
Panics
If id
is is not a valid argument or group name.
Examples
use std::ffi::OsString;
use std::os::unix::ffi::{OsStrExt,OsStringExt};
let m = Command::new("utf8")
.arg(arg!(<arg> "some arg")
.allow_invalid_utf8(true))
.get_matches_from(vec![OsString::from("myprog"),
// "Hi {0xe9}!"
OsString::from_vec(vec![b'H', b'i', b' ', 0xe9, b'!'])]);
assert_eq!(&*m.value_of_os("arg").unwrap().as_bytes(), [b'H', b'i', b' ', 0xe9, b'!']);
sourcepub fn values_of<T: Key>(&self, id: T) -> Option<Values<'_>>
pub fn values_of<T: Key>(&self, id: T) -> Option<Values<'_>>
Get an Iterator
over values of a specific option or positional argument.
i.e. an argument that takes multiple values at runtime.
Returns None
if the option wasn’t present.
Panics
If the value is invalid UTF-8. See
Arg::allow_invalid_utf8
.
If id
is is not a valid argument or group name.
Examples
let m = Command::new("myprog")
.arg(Arg::new("output")
.multiple_occurrences(true)
.short('o')
.takes_value(true))
.get_matches_from(vec![
"myprog", "-o", "val1", "-o", "val2", "-o", "val3"
]);
let vals: Vec<&str> = m.values_of("output").unwrap().collect();
assert_eq!(vals, ["val1", "val2", "val3"]);
sourcepub fn values_of_lossy<T: Key>(&self, id: T) -> Option<Vec<String>>
pub fn values_of_lossy<T: Key>(&self, id: T) -> Option<Vec<String>>
Get the lossy values of a specific option or positional argument.
i.e. an argument that takes multiple values at runtime.
A lossy value is one which contains invalid UTF-8, those invalid points will be replaced
with \u{FFFD}
Returns None
if the option wasn’t present.
NOTE: Recommend having set Arg::allow_invalid_utf8
.
Panics
If id
is is not a valid argument or group name.
Examples
use std::ffi::OsString;
use std::os::unix::ffi::OsStringExt;
let m = Command::new("utf8")
.arg(arg!(<arg> ... "some arg")
.allow_invalid_utf8(true))
.get_matches_from(vec![OsString::from("myprog"),
// "Hi"
OsString::from_vec(vec![b'H', b'i']),
// "{0xe9}!"
OsString::from_vec(vec![0xe9, b'!'])]);
let mut itr = m.values_of_lossy("arg").unwrap().into_iter();
assert_eq!(&itr.next().unwrap()[..], "Hi");
assert_eq!(&itr.next().unwrap()[..], "\u{FFFD}!");
assert_eq!(itr.next(), None);
sourcepub fn values_of_os<T: Key>(&self, id: T) -> Option<OsValues<'_>>
pub fn values_of_os<T: Key>(&self, id: T) -> Option<OsValues<'_>>
Get an Iterator
over OsStr
values of a specific option or positional argument.
i.e. an argument that takes multiple values at runtime.
An OsStr
on Unix-like systems is any series of bytes, regardless of whether or not they
contain valid UTF-8. Since String
s in Rust are guaranteed to be valid UTF-8, a valid
filename on a Unix system as an argument value may contain invalid UTF-8.
Returns None
if the option wasn’t present.
NOTE: Recommend having set Arg::allow_invalid_utf8
.
Panics
If id
is is not a valid argument or group name.
Examples
use std::ffi::{OsStr,OsString};
use std::os::unix::ffi::{OsStrExt,OsStringExt};
let m = Command::new("utf8")
.arg(arg!(<arg> ... "some arg")
.allow_invalid_utf8(true))
.get_matches_from(vec![OsString::from("myprog"),
// "Hi"
OsString::from_vec(vec![b'H', b'i']),
// "{0xe9}!"
OsString::from_vec(vec![0xe9, b'!'])]);
let mut itr = m.values_of_os("arg").unwrap().into_iter();
assert_eq!(itr.next(), Some(OsStr::new("Hi")));
assert_eq!(itr.next(), Some(OsStr::from_bytes(&[0xe9, b'!'])));
assert_eq!(itr.next(), None);
sourcepub fn value_of_t<R>(&self, name: &str) -> Result<R, Error> where
R: FromStr,
<R as FromStr>::Err: Display,
pub fn value_of_t<R>(&self, name: &str) -> Result<R, Error> where
R: FromStr,
<R as FromStr>::Err: Display,
Parse the value (with FromStr
) of a specific option or positional argument.
There are two types of errors, parse failures and those where the argument wasn’t present
(such as a non-required argument). Check ErrorKind
to distinguish them.
NOTE: If getting a value for an option or positional argument that allows multiples,
prefer ArgMatches::values_of_t
as this method will only return the first
value.
Panics
If the value is invalid UTF-8. See
Arg::allow_invalid_utf8
.
If id
is is not a valid argument or group name.
Examples
let matches = Command::new("myapp")
.arg(arg!([length] "Set the length to use as a pos whole num i.e. 20"))
.get_matches_from(&["test", "12"]);
// Specify the type explicitly (or use turbofish)
let len: u32 = matches.value_of_t("length").unwrap_or_else(|e| e.exit());
assert_eq!(len, 12);
// You can often leave the type for rustc to figure out
let also_len = matches.value_of_t("length").unwrap_or_else(|e| e.exit());
// Something that expects u32
let _: u32 = also_len;
sourcepub fn value_of_t_or_exit<R>(&self, name: &str) -> R where
R: FromStr,
<R as FromStr>::Err: Display,
pub fn value_of_t_or_exit<R>(&self, name: &str) -> R where
R: FromStr,
<R as FromStr>::Err: Display,
Parse the value (with FromStr
) of a specific option or positional argument.
If either the value is not present or parsing failed, exits the program.
Panics
If the value is invalid UTF-8. See
Arg::allow_invalid_utf8
.
If id
is is not a valid argument or group name.
Examples
let matches = Command::new("myapp")
.arg(arg!([length] "Set the length to use as a pos whole num i.e. 20"))
.get_matches_from(&["test", "12"]);
// Specify the type explicitly (or use turbofish)
let len: u32 = matches.value_of_t_or_exit("length");
assert_eq!(len, 12);
// You can often leave the type for rustc to figure out
let also_len = matches.value_of_t_or_exit("length");
// Something that expects u32
let _: u32 = also_len;
sourcepub fn values_of_t<R>(&self, name: &str) -> Result<Vec<R>, Error> where
R: FromStr,
<R as FromStr>::Err: Display,
pub fn values_of_t<R>(&self, name: &str) -> Result<Vec<R>, Error> where
R: FromStr,
<R as FromStr>::Err: Display,
Parse the values (with FromStr
) of a specific option or positional argument.
There are two types of errors, parse failures and those where the argument wasn’t present
(such as a non-required argument). Check ErrorKind
to distinguish them.
NOTE: If getting a value for an option or positional argument that allows multiples,
prefer ArgMatches::values_of_t
as this method will only return the first
value.
Panics
If the value is invalid UTF-8. See
Arg::allow_invalid_utf8
.
If id
is is not a valid argument or group name.
Examples
let matches = Command::new("myapp")
.arg(arg!([length] ... "A sequence of integers because integers are neat!"))
.get_matches_from(&["test", "12", "77", "40"]);
// Specify the type explicitly (or use turbofish)
let len: Vec<u32> = matches.values_of_t("length").unwrap_or_else(|e| e.exit());
assert_eq!(len, vec![12, 77, 40]);
// You can often leave the type for rustc to figure out
let also_len = matches.values_of_t("length").unwrap_or_else(|e| e.exit());
// Something that expects Vec<u32>
let _: Vec<u32> = also_len;
sourcepub fn values_of_t_or_exit<R>(&self, name: &str) -> Vec<R> where
R: FromStr,
<R as FromStr>::Err: Display,
pub fn values_of_t_or_exit<R>(&self, name: &str) -> Vec<R> where
R: FromStr,
<R as FromStr>::Err: Display,
Parse the values (with FromStr
) of a specific option or positional argument.
If parsing (of any value) has failed, exits the program.
Panics
If the value is invalid UTF-8. See
Arg::allow_invalid_utf8
.
If id
is is not a valid argument or group name.
Examples
let matches = Command::new("myapp")
.arg(arg!([length] ... "A sequence of integers because integers are neat!"))
.get_matches_from(&["test", "12", "77", "40"]);
// Specify the type explicitly (or use turbofish)
let len: Vec<u32> = matches.values_of_t_or_exit("length");
assert_eq!(len, vec![12, 77, 40]);
// You can often leave the type for rustc to figure out
let also_len = matches.values_of_t_or_exit("length");
// Something that expects Vec<u32>
let _: Vec<u32> = also_len;
sourcepub fn is_present<T: Key>(&self, id: T) -> bool
pub fn is_present<T: Key>(&self, id: T) -> bool
Check if an argument was present at runtime.
NOTE: This will always return true
if default_value
has been set.
occurrences_of
can be used to check if a value is present at runtime.
Panics
If id
is is not a valid argument or group name.
Examples
let m = Command::new("myprog")
.arg(Arg::new("debug")
.short('d'))
.get_matches_from(vec![
"myprog", "-d"
]);
assert!(m.is_present("debug"));
sourcepub fn value_source<T: Key>(&self, id: T) -> Option<ValueSource>
pub fn value_source<T: Key>(&self, id: T) -> Option<ValueSource>
sourcepub fn occurrences_of<T: Key>(&self, id: T) -> u64
pub fn occurrences_of<T: Key>(&self, id: T) -> u64
The number of times an argument was used at runtime.
If an argument isn’t present it will return 0
.
NOTE: This returns the number of times the argument was used, not the number of
values. For example, -o val1 val2 val3 -o val4
would return 2
(2 occurrences, but 4
values). See Arg::multiple_occurrences.
Panics
If id
is is not a valid argument or group name.
Examples
let m = Command::new("myprog")
.arg(Arg::new("debug")
.short('d')
.multiple_occurrences(true))
.get_matches_from(vec![
"myprog", "-d", "-d", "-d"
]);
assert_eq!(m.occurrences_of("debug"), 3);
This next example shows that counts actual uses of the argument, not just -
’s
let m = Command::new("myprog")
.arg(Arg::new("debug")
.short('d')
.multiple_occurrences(true))
.arg(Arg::new("flag")
.short('f'))
.get_matches_from(vec![
"myprog", "-ddfd"
]);
assert_eq!(m.occurrences_of("debug"), 3);
assert_eq!(m.occurrences_of("flag"), 1);
sourcepub fn index_of<T: Key>(&self, id: T) -> Option<usize>
pub fn index_of<T: Key>(&self, id: T) -> Option<usize>
The first index of that an argument showed up.
Indices are similar to argv indices, but are not exactly 1:1.
For flags (i.e. those arguments which don’t have an associated value), indices refer
to occurrence of the switch, such as -f
, or --flag
. However, for options the indices
refer to the values -o val
would therefore not represent two distinct indices, only the
index for val
would be recorded. This is by design.
Besides the flag/option discrepancy, the primary difference between an argv index and clap index, is that clap continues counting once all arguments have properly separated, whereas an argv index does not.
The examples should clear this up.
NOTE: If an argument is allowed multiple times, this method will only give the first
index. See ArgMatches::indices_of
.
Panics
If id
is is not a valid argument or group name.
Examples
The argv indices are listed in the comments below. See how they correspond to the clap
indices. Note that if it’s not listed in a clap index, this is because it’s not saved in
in an ArgMatches
struct for querying.
let m = Command::new("myapp")
.arg(Arg::new("flag")
.short('f'))
.arg(Arg::new("option")
.short('o')
.takes_value(true))
.get_matches_from(vec!["myapp", "-f", "-o", "val"]);
// ARGV indices: ^0 ^1 ^2 ^3
// clap indices: ^1 ^3
assert_eq!(m.index_of("flag"), Some(1));
assert_eq!(m.index_of("option"), Some(3));
Now notice, if we use one of the other styles of options:
let m = Command::new("myapp")
.arg(Arg::new("flag")
.short('f'))
.arg(Arg::new("option")
.short('o')
.takes_value(true))
.get_matches_from(vec!["myapp", "-f", "-o=val"]);
// ARGV indices: ^0 ^1 ^2
// clap indices: ^1 ^3
assert_eq!(m.index_of("flag"), Some(1));
assert_eq!(m.index_of("option"), Some(3));
Things become much more complicated, or clear if we look at a more complex combination of flags. Let’s also throw in the final option style for good measure.
let m = Command::new("myapp")
.arg(Arg::new("flag")
.short('f'))
.arg(Arg::new("flag2")
.short('F'))
.arg(Arg::new("flag3")
.short('z'))
.arg(Arg::new("option")
.short('o')
.takes_value(true))
.get_matches_from(vec!["myapp", "-fzF", "-oval"]);
// ARGV indices: ^0 ^1 ^2
// clap indices: ^1,2,3 ^5
//
// clap sees the above as 'myapp -f -z -F -o val'
// ^0 ^1 ^2 ^3 ^4 ^5
assert_eq!(m.index_of("flag"), Some(1));
assert_eq!(m.index_of("flag2"), Some(3));
assert_eq!(m.index_of("flag3"), Some(2));
assert_eq!(m.index_of("option"), Some(5));
One final combination of flags/options to see how they combine:
let m = Command::new("myapp")
.arg(Arg::new("flag")
.short('f'))
.arg(Arg::new("flag2")
.short('F'))
.arg(Arg::new("flag3")
.short('z'))
.arg(Arg::new("option")
.short('o')
.takes_value(true))
.get_matches_from(vec!["myapp", "-fzFoval"]);
// ARGV indices: ^0 ^1
// clap indices: ^1,2,3^5
//
// clap sees the above as 'myapp -f -z -F -o val'
// ^0 ^1 ^2 ^3 ^4 ^5
assert_eq!(m.index_of("flag"), Some(1));
assert_eq!(m.index_of("flag2"), Some(3));
assert_eq!(m.index_of("flag3"), Some(2));
assert_eq!(m.index_of("option"), Some(5));
The last part to mention is when values are sent in multiple groups with a delimiter.
let m = Command::new("myapp")
.arg(Arg::new("option")
.short('o')
.use_value_delimiter(true)
.multiple_values(true))
.get_matches_from(vec!["myapp", "-o=val1,val2,val3"]);
// ARGV indices: ^0 ^1
// clap indices: ^2 ^3 ^4
//
// clap sees the above as 'myapp -o val1 val2 val3'
// ^0 ^1 ^2 ^3 ^4
assert_eq!(m.index_of("option"), Some(2));
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[2, 3, 4]);
sourcepub fn indices_of<T: Key>(&self, id: T) -> Option<Indices<'_>>
pub fn indices_of<T: Key>(&self, id: T) -> Option<Indices<'_>>
All indices an argument appeared at when parsing.
Indices are similar to argv indices, but are not exactly 1:1.
For flags (i.e. those arguments which don’t have an associated value), indices refer
to occurrence of the switch, such as -f
, or --flag
. However, for options the indices
refer to the values -o val
would therefore not represent two distinct indices, only the
index for val
would be recorded. This is by design.
NOTE: For more information about how clap indices compared to argv indices, see
ArgMatches::index_of
Panics
If id
is is not a valid argument or group name.
Examples
let m = Command::new("myapp")
.arg(Arg::new("option")
.short('o')
.use_value_delimiter(true)
.multiple_values(true))
.get_matches_from(vec!["myapp", "-o=val1,val2,val3"]);
// ARGV indices: ^0 ^1
// clap indices: ^2 ^3 ^4
//
// clap sees the above as 'myapp -o val1 val2 val3'
// ^0 ^1 ^2 ^3 ^4
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[2, 3, 4]);
Another quick example is when flags and options are used together
let m = Command::new("myapp")
.arg(Arg::new("option")
.short('o')
.takes_value(true)
.multiple_occurrences(true))
.arg(Arg::new("flag")
.short('f')
.multiple_occurrences(true))
.get_matches_from(vec!["myapp", "-o", "val1", "-f", "-o", "val2", "-f"]);
// ARGV indices: ^0 ^1 ^2 ^3 ^4 ^5 ^6
// clap indices: ^2 ^3 ^5 ^6
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[2, 5]);
assert_eq!(m.indices_of("flag").unwrap().collect::<Vec<_>>(), &[3, 6]);
One final example, which is an odd case; if we don’t use value delimiter as we did with
the first example above instead of val1
, val2
and val3
all being distinc values, they
would all be a single value of val1,val2,val3
, in which case they’d only receive a single
index.
let m = Command::new("myapp")
.arg(Arg::new("option")
.short('o')
.takes_value(true)
.multiple_values(true))
.get_matches_from(vec!["myapp", "-o=val1,val2,val3"]);
// ARGV indices: ^0 ^1
// clap indices: ^2
//
// clap sees the above as 'myapp -o "val1,val2,val3"'
// ^0 ^1 ^2
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[2]);
sourcepub fn subcommand(&self) -> Option<(&str, &ArgMatches)>
pub fn subcommand(&self) -> Option<(&str, &ArgMatches)>
The name and ArgMatches
of the current subcommand.
Subcommand values are put in a child ArgMatches
Returns None
if the subcommand wasn’t present at runtime,
Examples
let app_m = Command::new("git")
.subcommand(Command::new("clone"))
.subcommand(Command::new("push"))
.subcommand(Command::new("commit"))
.get_matches();
match app_m.subcommand() {
Some(("clone", sub_m)) => {}, // clone was used
Some(("push", sub_m)) => {}, // push was used
Some(("commit", sub_m)) => {}, // commit was used
_ => {}, // Either no subcommand or one not tested for...
}
Another useful scenario is when you want to support third party, or external, subcommands. In these cases you can’t know the subcommand name ahead of time, so use a variable instead with pattern matching!
// Assume there is an external subcommand named "subcmd"
let app_m = Command::new("myprog")
.allow_external_subcommands(true)
.get_matches_from(vec![
"myprog", "subcmd", "--option", "value", "-fff", "--flag"
]);
// All trailing arguments will be stored under the subcommand's sub-matches using an empty
// string argument name
match app_m.subcommand() {
Some((external, sub_m)) => {
let ext_args: Vec<&str> = sub_m.values_of("").unwrap().collect();
assert_eq!(external, "subcmd");
assert_eq!(ext_args, ["--option", "value", "-fff", "--flag"]);
},
_ => {},
}
sourcepub fn subcommand_matches<T: Key>(&self, id: T) -> Option<&ArgMatches>
pub fn subcommand_matches<T: Key>(&self, id: T) -> Option<&ArgMatches>
The ArgMatches
for the current subcommand.
Subcommand values are put in a child ArgMatches
Returns None
if the subcommand wasn’t present at runtime,
Panics
If id
is is not a valid subcommand.
Examples
let app_m = Command::new("myprog")
.arg(Arg::new("debug")
.short('d'))
.subcommand(Command::new("test")
.arg(Arg::new("opt")
.long("option")
.takes_value(true)))
.get_matches_from(vec![
"myprog", "-d", "test", "--option", "val"
]);
// Both parent commands, and child subcommands can have arguments present at the same times
assert!(app_m.is_present("debug"));
// Get the subcommand's ArgMatches instance
if let Some(sub_m) = app_m.subcommand_matches("test") {
// Use the struct like normal
assert_eq!(sub_m.value_of("opt"), Some("val"));
}
sourcepub fn subcommand_name(&self) -> Option<&str>
pub fn subcommand_name(&self) -> Option<&str>
The name of the current subcommand.
Returns None
if the subcommand wasn’t present at runtime,
Examples
let app_m = Command::new("git")
.subcommand(Command::new("clone"))
.subcommand(Command::new("push"))
.subcommand(Command::new("commit"))
.get_matches();
match app_m.subcommand_name() {
Some("clone") => {}, // clone was used
Some("push") => {}, // push was used
Some("commit") => {}, // commit was used
_ => {}, // Either no subcommand or one not tested for...
}
Trait Implementations
sourceimpl Clone for ArgMatches
impl Clone for ArgMatches
sourcefn clone(&self) -> ArgMatches
fn clone(&self) -> ArgMatches
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl Debug for ArgMatches
impl Debug for ArgMatches
sourceimpl Default for ArgMatches
impl Default for ArgMatches
sourcefn default() -> ArgMatches
fn default() -> ArgMatches
Returns the “default value” for a type. Read more
sourceimpl PartialEq<ArgMatches> for ArgMatches
impl PartialEq<ArgMatches> for ArgMatches
sourcefn eq(&self, other: &ArgMatches) -> bool
fn eq(&self, other: &ArgMatches) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
sourcefn ne(&self, other: &ArgMatches) -> bool
fn ne(&self, other: &ArgMatches) -> bool
This method tests for !=
.
impl Eq for ArgMatches
impl StructuralEq for ArgMatches
impl StructuralPartialEq for ArgMatches
Auto Trait Implementations
impl RefUnwindSafe for ArgMatches
impl Send for ArgMatches
impl Sync for ArgMatches
impl Unpin for ArgMatches
impl UnwindSafe for ArgMatches
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more