# Enum clap::ClapErrorType [−] [src]

    pub enum ClapErrorType {
        InvalidValue,
        InvalidArgument,
        InvalidSubcommand,
        EmptyValue,
        ValueValidationError,
        ArgumentError,
        TooManyArgs,
        TooManyValues,
        TooFewValues,
        WrongNumValues,
        ArgumentConflict,
        MissingRequiredArgument,
        MissingSubcommand,
        MissingArgumentOrSubcommand,
        UnexpectedArgument,
        UnexpectedMultipleUsage,
        InvalidUnicode,
        HelpDisplayed,
        VersionDisplayed,
        InternalError,
        Io,
        Format,
    }

Command line argument parser error types

## Variants

`InvalidValue` | Error occurs when some possible values were set, but clap found unexpected value # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug").index(1)
            .possible_value("fast")
            .possible_value("slow"))
        .get_matches_from_safe(vec!["", "other"]);
`InvalidArgument` | Error occurs when clap found unexpected flag or option # Examples
    let result = App::new("myprog")
        .arg(Arg::from_usage("-f, --flag 'some flag'"))
        .get_matches_from_safe(vec!["", "--other"]);
`InvalidSubcommand` | Error occurs when clap found unexpected subcommand # Examples
    let result = App::new("myprog")
        .subcommand(SubCommand::with_name("config")
            .about("Used for configuration")
            .arg(Arg::with_name("config_file")
                .help("The configuration file to use")
                .index(1)))
        .get_matches_from_safe(vec!["", "other"]);
`EmptyValue` | Error occurs when option does not allow empty values but some was found # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug")
             .empty_values(false))
        .arg(Arg::with_name("color"))
        .get_matches_from_safe(vec!["", "--debug", "--color"]);
`ValueValidationError` | Option fails validation of a custom validator |
`ArgumentError` | Parser inner error |
`TooManyArgs` | Error occurs when an application got more arguments then were expected # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug").index(1)
            .max_values(2))
        .get_matches_from_safe(vec!["", "too", "much", "values"]);
`TooManyValues` | Error occurs when argument got more values then were expected # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug").index(1)
            .max_values(2))
        .get_matches_from_safe(vec!["", "too", "much", "values"]);
`TooFewValues` | Error occurs when argument got less values then were expected # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug").index(1)
            .min_values(3))
        .get_matches_from_safe(vec!["", "too", "few"]);
`WrongNumValues` | Error occurs when argument got a different number of values then were expected # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug").index(1)
            .max_values(2))
        .get_matches_from_safe(vec!["", "too", "much", "values"]);
`ArgumentConflict` | Error occurs when clap find two ore more conflicting arguments # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug")
            .conflicts_with("color"))
        .get_matches_from_safe(vec!["", "--debug", "--color"]);
`MissingRequiredArgument` | Error occurs when one or more required arguments missing # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug")
            .required(true))
        .get_matches_from_safe(vec![""]);
`MissingSubcommand` | Error occurs when required subcommand missing # Examples
    let result = App::new("myprog")
        .setting(AppSettings::SubcommandRequired)
        .subcommand(SubCommand::with_name("config")
            .about("Used for configuration")
            .arg(Arg::with_name("config_file")
                .help("The configuration file to use")
                .index(1)))
        .get_matches_from_safe(vec![""]);
`MissingArgumentOrSubcommand` | Occurs when no argument or subcommand has been supplied and `AppSettings::ArgRequiredElseHelp` was used # Examples
    let result = App::new("myprog")
        .setting(AppSettings::ArgRequiredElseHelp)
        .subcommand(SubCommand::with_name("config")
            .about("Used for configuration")
            .arg(Arg::with_name("config_file")
                .help("The configuration file to use")
                .index(1)))
        .get_matches_from_safe(vec![""]);
`UnexpectedArgument` | Error occurs when clap find argument while is was not expecting any # Examples
    let result = App::new("myprog")
        .get_matches_from_safe(vec!["", "--arg"]);
`UnexpectedMultipleUsage` | Error occurs when argument was used multiple times and was not set as multiple. # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug")
            .multiple(false))
        .get_matches_from_safe(vec!["", "--debug", "--debug"]);
`InvalidUnicode` | Error occurs when argument contains invalid unicode characters Note: Non-Windows OS only # Examples
    let result = App::new("myprog")
        .arg(Arg::with_name("debug")
            .short("u")
            .takes_value(true))
        .get_matches_from_safe(vec![OsString::from_vec(vec![0x20]),
                                    OsString::from_vec(vec![0xE9])]);
    assert!(result.is_err());
`HelpDisplayed` | Not a true 'error' as it means `--help` or similar was used. The help message will be sent to `stdout` unless the help is displayed due to an error (such as missing subcommands) at which point it will be sent to `stderr` # Examples
    let result = App::new("myprog")
        .get_matches_from_safe(vec!["", "--help"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().error_type, ClapErrorType::HelpDisplayed);
`VersionDisplayed` | Not a true 'error' as it means `--version` or similar was used. The message will be sent to `stdout` # Examples
    let result = App::new("myprog")
        .get_matches_from_safe(vec!["", "--version"]);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err().error_type, ClapErrorType::VersionDisplayed);
`InternalError` | Represents an internal error, please consider filing a bug report if this happens! |
`Io` | Represents an I/O error, typically white writing to stderr or stdout |
`Format` | Represents an Rust Display Format error, typically white writing to stderr or stdout |

## Trait Implementations

### Derived Implementations

### `impl PartialEq for ClapErrorType`

#### `fn eq(&self, __arg_0: &ClapErrorType) -> bool`

#### `fn ne(&self, __arg_0: &ClapErrorType) -> bool`

### `impl Clone for ClapErrorType`

#### `fn clone(&self) -> ClapErrorType`

#### 1.0.0 `fn clone_from(&mut self, source: &Self)`

### `impl Copy for ClapErrorType`

### `impl Debug for ClapErrorType`

#### `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`)