logo
pub struct ArgGroup<'help> { /* private fields */ }
Expand description

Family of related arguments.

By placing arguments in a logical group, you can create easier requirement and exclusion rules instead of having to list each argument individually, or when you want a rule to apply “any but not all” arguments.

For instance, you can make an entire ArgGroup required. If ArgGroup::multiple(true) is set, this means that at least one argument from that group must be present. If ArgGroup::multiple(false) is set (the default), one and only one must be present.

You can also do things such as name an entire ArgGroup as a conflict or requirement for another argument, meaning any of the arguments that belong to that group will cause a failure if present, or must be present respectively.

Perhaps the most common use of ArgGroups is to require one and only one argument to be present out of a given set. Imagine that you had multiple arguments, and you want one of them to be required, but making all of them required isn’t feasible because perhaps they conflict with each other. For example, lets say that you were building an application where one could set a given version number by supplying a string with an option argument, i.e. --set-ver v1.2.3, you also wanted to support automatically using a previous version number and simply incrementing one of the three numbers. So you create three flags --major, --minor, and --patch. All of these arguments shouldn’t be used at one time but you want to specify that at least one of them is used. For this, you can create a group.

Finally, you may use ArgGroups to pull a value from a group of arguments when you don’t care exactly which argument was actually used at runtime.

Examples

The following example demonstrates using an ArgGroup to ensure that one, and only one, of the arguments from the specified group is present at runtime.

let result = Command::new("cmd")
    .arg(arg!(--"set-ver" <ver> "set the version manually").required(false))
    .arg(arg!(--major           "auto increase major"))
    .arg(arg!(--minor           "auto increase minor"))
    .arg(arg!(--patch           "auto increase patch"))
    .group(ArgGroup::new("vers")
         .args(&["set-ver", "major", "minor", "patch"])
         .required(true))
    .try_get_matches_from(vec!["cmd", "--major", "--patch"]);
// Because we used two args in the group it's an error
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind(), ErrorKind::ArgumentConflict);

This next example shows a passing parse of the same scenario

let result = Command::new("cmd")
    .arg(arg!(--"set-ver" <ver> "set the version manually").required(false))
    .arg(arg!(--major           "auto increase major"))
    .arg(arg!(--minor           "auto increase minor"))
    .arg(arg!(--patch           "auto increase patch"))
    .group(ArgGroup::new("vers")
         .args(&["set-ver", "major", "minor","patch"])
         .required(true))
    .try_get_matches_from(vec!["cmd", "--major"]);
assert!(result.is_ok());
let matches = result.unwrap();
// We may not know which of the args was used, so we can test for the group...
assert!(matches.contains_id("vers"));
// we could also alternatively check each arg individually (not shown here)

Implementations

Create a ArgGroup using a unique name.

The name will be used to get values from the group or refer to the group inside of conflict and requirement rules.

Examples
ArgGroup::new("config")

Sets the group name.

Examples
ArgGroup::default().name("config")

Deprecated, replaced with ArgGroup::id

Adds an argument to this group by name

Examples
let m = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .group(ArgGroup::new("req_flags")
        .arg("flag")
        .arg("color"))
    .get_matches_from(vec!["myprog", "-f"]);
// maybe we don't know which of the two flags was used...
assert!(m.contains_id("req_flags"));
// but we can also check individually if needed
assert!(m.contains_id("flag"));

Adds multiple arguments to this group by name

Examples
let m = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"]))
    .get_matches_from(vec!["myprog", "-f"]);
// maybe we don't know which of the two flags was used...
assert!(m.contains_id("req_flags"));
// but we can also check individually if needed
assert!(m.contains_id("flag"));

Allows more than one of the Args in this group to be used. (Default: false)

Examples

Notice in this example we use both the -f and -c flags which are both part of the group

let m = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"])
        .multiple(true))
    .get_matches_from(vec!["myprog", "-f", "-c"]);
// maybe we don't know which of the two flags was used...
assert!(m.contains_id("req_flags"));

In this next example, we show the default behavior (i.e. `multiple(false)) which will throw an error if more than one of the args in the group was used.

let result = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"]))
    .try_get_matches_from(vec!["myprog", "-f", "-c"]);
// Because we used both args in the group it's an error
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind(), ErrorKind::ArgumentConflict);

Require an argument from the group to be present when parsing.

This is unless conflicting with another argument. A required group will be displayed in the usage string of the application in the format <arg|arg2|arg3>.

NOTE: This setting only applies to the current Command / Subcommands, and not globally.

NOTE: By default, ArgGroup::multiple is set to false which when combined with ArgGroup::required(true) states, “One and only one arg must be used from this group. Use of more than one arg is an error.” Vice setting ArgGroup::multiple(true) which states, ’At least one arg from this group must be used. Using multiple is OK.“

Examples
let result = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"])
        .required(true))
    .try_get_matches_from(vec!["myprog"]);
// Because we didn't use any of the args in the group, it's an error
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind(), ErrorKind::MissingRequiredArgument);

Specify an argument or group that must be present when this group is.

This is not to be confused with a required group. Requirement rules function just like argument requirement rules, you can name other arguments or groups that must be present when any one of the arguments from this group is used.

NOTE: The name provided may be an argument or group name

Examples
let result = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .arg(Arg::new("debug")
        .short('d'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"])
        .requires("debug"))
    .try_get_matches_from(vec!["myprog", "-c"]);
// because we used an arg from the group, and the group requires "-d" to be used, it's an
// error
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind(), ErrorKind::MissingRequiredArgument);

Specify arguments or groups that must be present when this group is.

This is not to be confused with a required group. Requirement rules function just like argument requirement rules, you can name other arguments or groups that must be present when one of the arguments from this group is used.

NOTE: The names provided may be an argument or group name

Examples
let result = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .arg(Arg::new("debug")
        .short('d'))
    .arg(Arg::new("verb")
        .short('v'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"])
        .requires_all(&["debug", "verb"]))
    .try_get_matches_from(vec!["myprog", "-c", "-d"]);
// because we used an arg from the group, and the group requires "-d" and "-v" to be used,
// yet we only used "-d" it's an error
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind(), ErrorKind::MissingRequiredArgument);

Specify an argument or group that must not be present when this group is.

Exclusion (aka conflict) rules function just like argument exclusion rules, you can name other arguments or groups that must not be present when one of the arguments from this group are used.

NOTE: The name provided may be an argument, or group name

Examples
let result = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .arg(Arg::new("debug")
        .short('d'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"])
        .conflicts_with("debug"))
    .try_get_matches_from(vec!["myprog", "-c", "-d"]);
// because we used an arg from the group, and the group conflicts with "-d", it's an error
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind(), ErrorKind::ArgumentConflict);

Specify arguments or groups that must not be present when this group is.

Exclusion rules function just like argument exclusion rules, you can name other arguments or groups that must not be present when one of the arguments from this group are used.

NOTE: The names provided may be an argument, or group name

Examples
let result = Command::new("myprog")
    .arg(Arg::new("flag")
        .short('f'))
    .arg(Arg::new("color")
        .short('c'))
    .arg(Arg::new("debug")
        .short('d'))
    .arg(Arg::new("verb")
        .short('v'))
    .group(ArgGroup::new("req_flags")
        .args(&["flag", "color"])
        .conflicts_with_all(&["debug", "verb"]))
    .try_get_matches_from(vec!["myprog", "-c", "-v"]);
// because we used an arg from the group, and the group conflicts with either "-v" or "-d"
// it's an error
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.kind(), ErrorKind::ArgumentConflict);

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Converts to this type from the input type.

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

This method tests for !=.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Compare self to key and return true if they are equal.

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.