Struct cargo::util::command_prelude::ArgMatches
pub struct ArgMatches {
pub(crate) args: FlatMap<Id, MatchedArg>,
pub(crate) subcommand: Option<Box<SubCommand>>,
}
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)
.action(ArgAction::Set)
.default_value("-"))
.arg(Arg::new("cfg")
.short('c')
.action(ArgAction::Set))
.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::get_one]
if let Some(c) = matches.get_one::<String>("cfg") {
println!("Value for -c: {c}");
}
// The ArgMatches::get_one 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.get_one::<String>("out").unwrap());
// You can check the presence of an argument's values
if matches.contains_id("out") {
// However, if you want to know where the value came from
if matches.value_source("out").expect("checked contains_id") == ValueSource::CommandLine {
println!("`out` set by user");
} else {
println!("`out` is defaulted");
}
}
Fields§
§args: FlatMap<Id, MatchedArg>
§subcommand: Option<Box<SubCommand>>
Implementations§
§impl ArgMatches
impl ArgMatches
§Arguments
pub fn get_one<T>(&self, id: &str) -> Option<&T>
pub fn get_one<T>(&self, id: &str) -> Option<&T>
Gets the value of a specific option or positional argument.
i.e. an argument that takes an additional value at runtime.
Returns an error if the wrong type was used.
Returns None
if the option wasn’t present.
NOTE: This will always return Some(value)
if default_value
has been set.
ArgMatches::value_source
can be used to check if a value is present at runtime.
§Panic
If the argument definition and access mismatch. To handle this case programmatically, see
ArgMatches::try_get_one
.
§Examples
let m = Command::new("myapp")
.arg(Arg::new("port")
.value_parser(value_parser!(usize))
.action(ArgAction::Set)
.required(true))
.get_matches_from(vec!["myapp", "2020"]);
let port: usize = *m
.get_one("port")
.expect("`port`is required");
assert_eq!(port, 2020);
pub fn get_count(&self, id: &str) -> u8
pub fn get_count(&self, id: &str) -> u8
Gets the value of a specific ArgAction::Count
flag
§Panic
If the argument’s action is not ArgAction::Count
§Examples
let cmd = Command::new("mycmd")
.arg(
Arg::new("flag")
.long("flag")
.action(clap::ArgAction::Count)
);
let matches = cmd.clone().try_get_matches_from(["mycmd", "--flag", "--flag"]).unwrap();
assert_eq!(
matches.get_count("flag"),
2
);
pub fn get_flag(&self, id: &str) -> bool
pub fn get_flag(&self, id: &str) -> bool
Gets the value of a specific ArgAction::SetTrue
or ArgAction::SetFalse
flag
§Panic
If the argument’s action is not ArgAction::SetTrue
or ArgAction::SetFalse
§Examples
let cmd = Command::new("mycmd")
.arg(
Arg::new("flag")
.long("flag")
.action(clap::ArgAction::SetTrue)
);
let matches = cmd.clone().try_get_matches_from(["mycmd", "--flag"]).unwrap();
assert!(matches.contains_id("flag"));
assert_eq!(
matches.get_flag("flag"),
true
);
pub fn get_many<T>(&self, id: &str) -> Option<ValuesRef<'_, T>>
pub fn get_many<T>(&self, id: &str) -> Option<ValuesRef<'_, T>>
Iterate over values of a specific option or positional argument.
i.e. an argument that takes multiple values at runtime.
Returns an error if the wrong type was used.
Returns None
if the option wasn’t present.
§Panic
If the argument definition and access mismatch. To handle this case programmatically, see
ArgMatches::try_get_many
.
§Examples
let m = Command::new("myprog")
.arg(Arg::new("ports")
.action(ArgAction::Append)
.value_parser(value_parser!(usize))
.short('p')
.required(true))
.get_matches_from(vec![
"myprog", "-p", "22", "-p", "80", "-p", "2020"
]);
let vals: Vec<usize> = m.get_many("ports")
.expect("`port`is required")
.copied()
.collect();
assert_eq!(vals, [22, 80, 2020]);
pub fn get_occurrences<T>(&self, id: &str) -> Option<OccurrencesRef<'_, T>>
pub fn get_occurrences<T>(&self, id: &str) -> Option<OccurrencesRef<'_, T>>
Iterate over the values passed to each occurrence of an option.
Each item is itself an iterator containing the arguments passed to a single occurrence of the option.
If the option doesn’t support multiple occurrences, or there was only a single occurrence, the iterator will only contain a single item.
Returns None
if the option wasn’t present.
§Panics
If the argument definition and access mismatch (debug builds). To handle this case programmatically, see
ArgMatches::try_get_occurrences
.
§Examples
let m = Command::new("myprog")
.arg(Arg::new("x")
.short('x')
.num_args(2)
.action(ArgAction::Append)
.value_parser(value_parser!(String)))
.get_matches_from(vec![
"myprog", "-x", "a", "b", "-x", "c", "d"]);
let vals: Vec<Vec<&String>> = m.get_occurrences("x").unwrap().map(Iterator::collect).collect();
assert_eq!(vals, [["a", "b"], ["c", "d"]]);
pub fn get_raw(&self, id: &str) -> Option<RawValues<'_>>
pub fn get_raw(&self, id: &str) -> Option<RawValues<'_>>
Iterate over the original argument values.
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.
§Panic
If the argument definition and access mismatch. To handle this case programmatically, see
ArgMatches::try_get_raw
.
§Examples
use std::path::PathBuf;
let m = Command::new("utf8")
.arg(arg!(<arg> ... "some arg").value_parser(value_parser!(PathBuf)))
.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.get_raw("arg")
.expect("`port`is required")
.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);
pub fn get_raw_occurrences(&self, id: &str) -> Option<RawOccurrences<'_>>
pub fn get_raw_occurrences(&self, id: &str) -> Option<RawOccurrences<'_>>
Iterate over the original values for each occurrence of an option.
Similar to ArgMatches::get_occurrences
but returns raw values.
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.
§Panic
If the argument definition and access mismatch. To handle this case programmatically, see
ArgMatches::try_get_raw_occurrences
.
§Examples
use std::path::PathBuf;
let m = Command::new("myprog")
.arg(Arg::new("x")
.short('x')
.num_args(2)
.action(ArgAction::Append)
.value_parser(value_parser!(PathBuf)))
.get_matches_from(vec![OsString::from("myprog"),
OsString::from("-x"),
OsString::from("a"), OsString::from("b"),
OsString::from("-x"),
OsString::from("c"),
// "{0xe9}!"
OsString::from_vec(vec![0xe9, b'!'])]);
let mut itr = m.get_raw_occurrences("x")
.expect("`-x`is required")
.map(Iterator::collect::<Vec<_>>);
assert_eq!(itr.next(), Some(vec![OsStr::new("a"), OsStr::new("b")]));
assert_eq!(itr.next(), Some(vec![OsStr::new("c"), OsStr::from_bytes(&[0xe9, b'!'])]));
assert_eq!(itr.next(), None);
pub fn remove_one<T>(&mut self, id: &str) -> Option<T>
pub fn remove_one<T>(&mut self, id: &str) -> Option<T>
Returns the value of a specific option or positional argument.
i.e. an argument that takes an additional value at runtime.
Returns an error if the wrong type was used. No item will have been removed.
Returns None
if the option wasn’t present.
NOTE: This will always return Some(value)
if default_value
has been set.
ArgMatches::value_source
can be used to check if a value is present at runtime.
§Panic
If the argument definition and access mismatch. To handle this case programmatically, see
ArgMatches::try_remove_one
.
§Examples
let mut m = Command::new("myprog")
.arg(Arg::new("file")
.required(true)
.action(ArgAction::Set))
.get_matches_from(vec![
"myprog", "file.txt",
]);
let vals: String = m.remove_one("file")
.expect("`file`is required");
assert_eq!(vals, "file.txt");
pub fn remove_many<T>(&mut self, id: &str) -> Option<Values<T>>
pub fn remove_many<T>(&mut self, id: &str) -> Option<Values<T>>
Return values of a specific option or positional argument.
i.e. an argument that takes multiple values at runtime.
Returns an error if the wrong type was used. No item will have been removed.
Returns None
if the option wasn’t present.
§Panic
If the argument definition and access mismatch. To handle this case programmatically, see
ArgMatches::try_remove_many
.
§Examples
let mut m = Command::new("myprog")
.arg(Arg::new("file")
.action(ArgAction::Append)
.num_args(1..)
.required(true))
.get_matches_from(vec![
"myprog", "file1.txt", "file2.txt", "file3.txt", "file4.txt",
]);
let vals: Vec<String> = m.remove_many("file")
.expect("`file`is required")
.collect();
assert_eq!(vals, ["file1.txt", "file2.txt", "file3.txt", "file4.txt"]);
pub fn remove_occurrences<T>(&mut self, id: &str) -> Option<Occurrences<T>>
pub fn remove_occurrences<T>(&mut self, id: &str) -> Option<Occurrences<T>>
Return values for each occurrence of an option.
Each item is itself an iterator containing the arguments passed to a single occurrence of the option.
If the option doesn’t support multiple occurrences, or there was only a single occurrence, the iterator will only contain a single item.
Returns None
if the option wasn’t present.
§Panic
If the argument definition and access mismatch. To handle this case programmatically, see
ArgMatches::try_remove_occurrences
.
§Examples
let mut m = Command::new("myprog")
.arg(Arg::new("x")
.short('x')
.num_args(2)
.action(ArgAction::Append)
.value_parser(value_parser!(String)))
.get_matches_from(vec![
"myprog", "-x", "a", "b", "-x", "c", "d"]);
let vals: Vec<Vec<String>> = m.remove_occurrences("x").unwrap().map(Iterator::collect).collect();
assert_eq!(vals, [["a", "b"], ["c", "d"]]);
pub fn contains_id(&self, id: &str) -> bool
pub fn contains_id(&self, id: &str) -> bool
Check if values are present for the argument or group id
NOTE: This will always return true
if default_value
has been set.
ArgMatches::value_source
can be used to check if a value is present at runtime.
§Panics
If id
is not a valid argument or group name (debug builds). To handle this case programmatically, see
ArgMatches::try_contains_id
.
§Examples
let m = Command::new("myprog")
.arg(Arg::new("debug")
.short('d')
.action(ArgAction::SetTrue))
.get_matches_from(vec![
"myprog", "-d"
]);
assert!(m.contains_id("debug"));
pub fn ids(&self) -> IdsRef<'_>
pub fn ids(&self) -> IdsRef<'_>
Iterate over Arg
and [ArgGroup
][crate::ArgGroup] [Id
]s via ArgMatches::ids
.
§Examples
let m = Command::new("myprog")
.arg(arg!(--color <when>)
.value_parser(["auto", "always", "never"]))
.arg(arg!(--config <path>)
.value_parser(value_parser!(std::path::PathBuf)))
.get_matches_from(["myprog", "--config=config.toml", "--color=auto"]);
assert_eq!(m.ids().len(), 2);
assert_eq!(
m.ids()
.map(|id| id.as_str())
.collect::<Vec<_>>(),
["config", "color"]
);
pub 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")
.action(ArgAction::Set));
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());
pub fn value_source(&self, id: &str) -> Option<ValueSource>
pub fn value_source(&self, id: &str) -> Option<ValueSource>
Report where argument value came from
§Panics
If id
is not a valid argument or group id (debug builds).
§Examples
let m = Command::new("myprog")
.arg(Arg::new("debug")
.short('d')
.action(ArgAction::SetTrue))
.get_matches_from(vec![
"myprog", "-d"
]);
assert_eq!(m.value_source("debug"), Some(ValueSource::CommandLine));
pub fn index_of(&self, id: &str) -> Option<usize>
pub fn index_of(&self, id: &str) -> 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 not a valid argument or group id (debug builds).
§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')
.action(ArgAction::SetTrue))
.arg(Arg::new("option")
.short('o')
.action(ArgAction::Set))
.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')
.action(ArgAction::SetTrue))
.arg(Arg::new("option")
.short('o')
.action(ArgAction::Set))
.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')
.action(ArgAction::SetTrue))
.arg(Arg::new("flag2")
.short('F')
.action(ArgAction::SetTrue))
.arg(Arg::new("flag3")
.short('z')
.action(ArgAction::SetTrue))
.arg(Arg::new("option")
.short('o')
.action(ArgAction::Set))
.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')
.action(ArgAction::SetTrue))
.arg(Arg::new("flag2")
.short('F')
.action(ArgAction::SetTrue))
.arg(Arg::new("flag3")
.short('z')
.action(ArgAction::SetTrue))
.arg(Arg::new("option")
.short('o')
.action(ArgAction::Set))
.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')
.value_delimiter(',')
.num_args(1..))
.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]);
pub fn indices_of(&self, id: &str) -> Option<Indices<'_>>
pub fn indices_of(&self, id: &str) -> 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 not a valid argument or group id (debug builds).
§Examples
let m = Command::new("myapp")
.arg(Arg::new("option")
.short('o')
.value_delimiter(','))
.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')
.action(ArgAction::Set)
.action(ArgAction::Append))
.arg(Arg::new("flag")
.short('f')
.action(ArgAction::Count))
.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<_>>(), &[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')
.action(ArgAction::Set)
.num_args(1..))
.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]);
§impl ArgMatches
impl ArgMatches
§Subcommands
pub 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<&OsStr> = sub_m.get_many::<OsString>("")
.unwrap().map(|s| s.as_os_str()).collect();
assert_eq!(external, "subcmd");
assert_eq!(ext_args, ["--option", "value", "-fff", "--flag"]);
},
_ => {},
}
pub fn remove_subcommand(&mut self) -> Option<(String, ArgMatches)>
pub fn remove_subcommand(&mut self) -> Option<(String, ArgMatches)>
Return 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 mut app_m = Command::new("git")
.subcommand(Command::new("clone"))
.subcommand(Command::new("push"))
.subcommand(Command::new("commit"))
.subcommand_required(true)
.get_matches();
let (name, sub_m) = app_m.remove_subcommand().expect("required");
match (name.as_str(), sub_m) {
("clone", sub_m) => {}, // clone was used
("push", sub_m) => {}, // push was used
("commit", sub_m) => {}, // commit was used
(name, _) => unimplemented!("{name}"),
}
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 mut 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.remove_subcommand() {
Some((external, mut sub_m)) => {
let ext_args: Vec<OsString> = sub_m.remove_many("")
.expect("`file`is required")
.collect();
assert_eq!(external, "subcmd");
assert_eq!(ext_args, ["--option", "value", "-fff", "--flag"]);
},
_ => {},
}
pub fn subcommand_matches(&self, name: &str) -> Option<&ArgMatches>
pub fn subcommand_matches(&self, name: &str) -> 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 not a valid subcommand (debug builds).
§Examples
let app_m = Command::new("myprog")
.arg(Arg::new("debug")
.short('d')
.action(ArgAction::SetTrue)
)
.subcommand(Command::new("test")
.arg(Arg::new("opt")
.long("option")
.action(ArgAction::Set)))
.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.get_flag("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.get_one::<String>("opt").map(|s| s.as_str()), Some("val"));
}
pub 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...
}
§impl ArgMatches
impl ArgMatches
§Advanced
pub fn try_get_one<T>(&self, id: &str) -> Result<Option<&T>, MatchesError>
pub fn try_get_one<T>(&self, id: &str) -> Result<Option<&T>, MatchesError>
Non-panicking version of ArgMatches::get_one
pub fn try_get_many<T>(
&self,
id: &str,
) -> Result<Option<ValuesRef<'_, T>>, MatchesError>
pub fn try_get_many<T>( &self, id: &str, ) -> Result<Option<ValuesRef<'_, T>>, MatchesError>
Non-panicking version of ArgMatches::get_many
pub fn try_get_occurrences<T>(
&self,
id: &str,
) -> Result<Option<OccurrencesRef<'_, T>>, MatchesError>
pub fn try_get_occurrences<T>( &self, id: &str, ) -> Result<Option<OccurrencesRef<'_, T>>, MatchesError>
Non-panicking version of ArgMatches::get_occurrences
pub fn try_get_raw(
&self,
id: &str,
) -> Result<Option<RawValues<'_>>, MatchesError>
pub fn try_get_raw( &self, id: &str, ) -> Result<Option<RawValues<'_>>, MatchesError>
Non-panicking version of ArgMatches::get_raw
pub fn try_get_raw_occurrences(
&self,
id: &str,
) -> Result<Option<RawOccurrences<'_>>, MatchesError>
pub fn try_get_raw_occurrences( &self, id: &str, ) -> Result<Option<RawOccurrences<'_>>, MatchesError>
Non-panicking version of ArgMatches::get_raw_occurrences
pub fn try_remove_one<T>(&mut self, id: &str) -> Result<Option<T>, MatchesError>
pub fn try_remove_one<T>(&mut self, id: &str) -> Result<Option<T>, MatchesError>
Non-panicking version of ArgMatches::remove_one
pub fn try_remove_many<T>(
&mut self,
id: &str,
) -> Result<Option<Values<T>>, MatchesError>
pub fn try_remove_many<T>( &mut self, id: &str, ) -> Result<Option<Values<T>>, MatchesError>
Non-panicking version of ArgMatches::remove_many
pub fn try_remove_occurrences<T>(
&mut self,
id: &str,
) -> Result<Option<Occurrences<T>>, MatchesError>
pub fn try_remove_occurrences<T>( &mut self, id: &str, ) -> Result<Option<Occurrences<T>>, MatchesError>
Non-panicking version of ArgMatches::remove_occurrences
pub fn try_contains_id(&self, id: &str) -> Result<bool, MatchesError>
pub fn try_contains_id(&self, id: &str) -> Result<bool, MatchesError>
Non-panicking version of ArgMatches::contains_id
Trait Implementations§
source§impl<'a> ArgMatchesExt for ArgMatches
impl<'a> ArgMatchesExt for ArgMatches
fn flag(&self, name: &str) -> bool
fn maybe_flag(&self, name: &str) -> bool
fn _value_of(&self, name: &str) -> Option<&str>
fn _value_of_os(&self, name: &str) -> Option<&OsStr>
fn _values_of(&self, name: &str) -> Vec<String>
fn _values_of_os(&self, name: &str) -> Vec<OsString>
fn _count(&self, name: &str) -> u32
fn _contains(&self, name: &str) -> bool
fn value_of_u32(&self, name: &str) -> CargoResult<Option<u32>>
fn value_of_i32(&self, name: &str) -> CargoResult<Option<i32>>
source§fn value_of_path(&self, name: &str, gctx: &GlobalContext) -> Option<PathBuf>
fn value_of_path(&self, name: &str, gctx: &GlobalContext) -> Option<PathBuf>
name
command-line argument as an absolute pathfn root_manifest(&self, gctx: &GlobalContext) -> CargoResult<PathBuf>
fn lockfile_path(&self, gctx: &GlobalContext) -> CargoResult<Option<PathBuf>>
fn workspace<'a>(&self, gctx: &'a GlobalContext) -> CargoResult<Workspace<'a>>
fn jobs(&self) -> CargoResult<Option<JobsConfig>>
fn verbose(&self) -> u32
fn dry_run(&self) -> bool
fn keep_going(&self) -> bool
fn honor_rust_version(&self) -> Option<bool>
fn targets(&self) -> CargoResult<Vec<String>>
fn get_profile_name( &self, default: &str, profile_checking: ProfileChecking, ) -> CargoResult<InternedString>
fn packages_from_flags(&self) -> CargoResult<Packages>
fn compile_options( &self, gctx: &GlobalContext, mode: CompileMode, workspace: Option<&Workspace<'_>>, profile_checking: ProfileChecking, ) -> CargoResult<CompileOptions>
fn cli_features(&self) -> CargoResult<CliFeatures>
fn compile_options_for_single_package( &self, gctx: &GlobalContext, mode: CompileMode, workspace: Option<&Workspace<'_>>, profile_checking: ProfileChecking, ) -> CargoResult<CompileOptions>
fn new_options(&self, gctx: &GlobalContext) -> CargoResult<NewOptions>
fn registry_or_index( &self, gctx: &GlobalContext, ) -> CargoResult<Option<RegistryOrIndex>>
fn registry(&self, gctx: &GlobalContext) -> CargoResult<Option<String>>
fn check_optional_opts( &self, workspace: &Workspace<'_>, compile_opts: &CompileOptions, ) -> CargoResult<()>
fn is_present_with_zero_values(&self, name: &str) -> bool
§impl Clone for ArgMatches
impl Clone for ArgMatches
§fn clone(&self) -> ArgMatches
fn clone(&self) -> ArgMatches
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more§impl Debug for ArgMatches
impl Debug for ArgMatches
§impl Default for ArgMatches
impl Default for ArgMatches
§fn default() -> ArgMatches
fn default() -> ArgMatches
§impl PartialEq for ArgMatches
impl PartialEq for ArgMatches
impl Eq for ArgMatches
impl StructuralPartialEq for ArgMatches
Auto Trait Implementations§
impl Freeze for ArgMatches
impl !RefUnwindSafe for ArgMatches
impl Send for ArgMatches
impl Sync for ArgMatches
impl Unpin for ArgMatches
impl !UnwindSafe for ArgMatches
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,
§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 56 bytes