# Struct clap::ArgMatches [−] [src]

    pub struct ArgMatches<'n, 'a> {
        // some fields omitted
    }

Used to get information about the arguments that where supplied to the program at runtime by the user. To get a new instance of this struct you use `.get_matches()` of the `App` struct.

# Examples

    let matches = App::new("MyApp")
    // adding of arguments and configuration goes here...
                        .get_matches();
    // if you had an argument named "output" that takes a value
    if let Some(o) = matches.value_of("output") {
        println!("Value for output: {}", o);
    }

    // If you have a required argument you can call .unwrap() because the program will exit long
    // before this point if the user didn't specify it at runtime.
    println!("Config file: {}", matches.value_of("config").unwrap());

    // You can check the presence of an argument
    if matches.is_present("debug") {
        // 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(true) method, otherwise it will only return 1 or 0.
        if matches.occurrences_of("debug") > 2 {
            println!("Debug mode is REALLY on");
        } else {
            println!("Debug mode kind of on");
        }
    }

    // You can get the sub-matches of a particular subcommand (in this case "test")
    // If "test" had it's own "-l" flag you could check for it's presence accordingly
    if let Some(ref matches) = matches.subcommand_matches("test") {
        if matches.is_present("list") {
            println!("Printing testing lists...");
        } else {
            println!("Not printing testing lists...");
        }
    }

## Methods

### `impl<'n, 'a> ArgMatches<'n, 'a>`

#### `fn value_of(&self, name: &str) -> Option<&str>`

Gets the value of a specific option or positional argument (i.e. an argument that takes an additional value at runtime). If the option wasn't present at runtime it returns `None`.

NOTE: If getting a value for an option or positional argument that allows multiples, prefer `values_of()` as `value_of()` will only return the first value.

# Examples

    if let Some(o) = matches.value_of("output") {
           println!("Value for output: {}", o);
    }

#### `fn values_of(&'a self, name: &str) -> Option<Vec<&'a str>>`

Gets the values of a specific option or positional argument in a vector (i.e. an argument that takes multiple values at runtime). If the option wasn't present at runtime it returns `None`

# Examples

    // If the program had option "-c" that took a value and was run
    // via "myapp -o some -o other -o file"
    // values_of() would return a [&str; 3] ("some", "other", "file")
    if let Some(os) = matches.values_of("output") {
           for o in os {
               println!("A value for output: {}", o);
           }
    }

#### `fn is_present(&self, name: &str) -> bool`

Returns if an argument was present at runtime.

# Examples

    if matches.is_present("output") {
           println!("The output argument was used!");
    }

#### `fn occurrences_of(&self, name: &str) -> u8`

Returns the number of occurrences of an option, flag, or positional argument at runtime. If an argument isn't present it will return `0`. Can be used on arguments which don't allow multiple occurrences, but will obviously only return `0` or `1`.

# Examples

    if matches.occurrences_of("debug") > 1 {
        println!("Debug mode is REALLY on");
    } else {
        println!("Debug mode kind of on");
    }

#### `fn subcommand_matches<'na>(&self, name: &'na str) -> Option<&ArgMatches>`

Returns the `ArgMatches` for a particular subcommand or None if the subcommand wasn't present at runtime.

# Examples

    if let Some(matches) = app_matches.subcommand_matches("test") {
        // Use matches as normal
    }

#### `fn subcommand_name(&self) -> Option<&str>`

Returns the name of the subcommand used of the parent `App`, or `None` if one wasn't found

NOTE: Only a single subcommand may be present per `App` at runtime, does NOT check for the name of sub-subcommand's names

# Examples

    match app_matches.subcommand_name() {
        Some("test")   => {}, // test was used
        Some("config") => {}, // config was used
        _              => {}, // Either no subcommand or one not tested for...
    }

#### `fn subcommand(&self) -> (&str, Option<&ArgMatches>)`

Returns the name and `ArgMatches` of the subcommand used at runtime or ("", None) if one wasn't found.

# Examples

    match app_matches.subcommand() {
        ("test", Some(matches))   => {}, // test was used
        ("config", Some(matches)) => {}, // config was used
        _                         => {}, // Either no subcommand or one not tested for...
    }

#### `fn usage(&self) -> &str`

Returns a string slice of the usage statement for the `App` (or `SubCommand`)

# Examples

    println!("{}",app_matches.usage());

## Trait Implementations

### Derived Implementations

### `impl<'n, 'a> Debug for ArgMatches<'n, 'a>`

#### `fn fmt(&self, __arg_0: &mut Formatter) -> Result`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)