Struct Args

pub struct Args<'a, T = Results<'a>> {
    pub name: &'a str,
    pub path: Option<&'a str>,
    pub version: &'a str,
    pub about: &'a str,
    pub args: Vec<Arg<'a>>,
    pub disable_overrides: bool,
    pub fail_on_unknown_args: bool,
    pub subcommands: Vec<Args<'a, T>>,
    pub handler: fn(Results<'a>) -> T,
    pub filters: Filters<'a>,
}

Struct defining the collection of args we support

Fields

name: &'a str

name of this command (if it’s the root) or subcommand if ommitted this will default to the cargo package name (even with subcommands)

path: Option<&'a str>

If this subcommand is matched this field will be returned alongside the Results, with the intention that it can be used to uniquely identify which Args struct was matched (although uniqueness is not enforced). This is needed because the name field can be repeated in nested subcommands, e.g ./foo help ./foo subcommand help where “help” is the name This field is also used in the –version && –help command, so we recommend that this mirrors the cli call used, e.g if name = “subcommand” then path = “root subcommand”

version: &'a str

The program version, used by the –version command if ommitted this will default to the cargo package version (even with subcommands)

about: &'a str

About string included in the –help command if ommitted this will default to the cargo package description (even with subcommands)

args: Vec<Arg<'a>>

Collections of args that we will look for under this command. Any matched will be included in the Results params or flags.

disable_overrides: bool

Whether to fail if an arg is seen multiple times. Defaults to false

fail_on_unknown_args: bool

Whether to fail if any unknown args are given. Defaults to false

subcommands: Vec<Args<'a, T>>

List of subcommands underneath this command

handler: fn(Results<'a>) -> T

handler to invoke when this command has been found. This is not called if a subcommand is invoked

filters: Filters<'a>

Filter conditions to restrict the combinations of args this command supports

Implementations

impl<'a, R> Args<'a, R>

pub fn parse<S: IntoStr, T: IntoIterator<Item = S>>( &'a self, args: T, ) -> Result<R, Error<'a>>

Trait Implementations

impl<'a, T: Handler<'a, T>> Default for Args<'a, T>

fn default() -> Self

Returns the “default value” for a type.