Enum clap::ErrorKind
[−]
[src]
pub enum ErrorKind { InvalidValue, UnknownArgument, InvalidSubcommand, UnrecognizedSubcommand, EmptyValue, ValueValidation, TooManyValues, TooFewValues, WrongNumberOfValues, ArgumentConflict, MissingRequiredArgument, MissingSubcommand, MissingArgumentOrSubcommand, UnexpectedMultipleUsage, InvalidUtf8, HelpDisplayed, VersionDisplayed, ArgumentNotFound, Io, Format, }
Command line argument parser kind of error
Variants
InvalidValue
Occurs when an Arg
has a set of possible values, and the user provides a value which
isn't in that set.
Examples
let result = App::new("myprog") .arg(Arg::with_name("speed") .possible_value("fast") .possible_value("slow")) .get_matches_from_safe(vec!["myprog", "other"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidValue);
UnknownArgument
Occurs when a user provides a flag, option, or argument which wasn't defined.
Examples
let result = App::new("myprog") .arg(Arg::from_usage("--flag 'some flag'")) .get_matches_from_safe(vec!["myprog", "--other"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::UnknownArgument);
InvalidSubcommand
Occurs when the user provids an unrecognized SubCommand
which meets the threshold for
being similar enough to an existing subcommand so as to not cause the more general
UnknownArgument
error.
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!["myprog", "confi"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidSubcommand);
UnrecognizedSubcommand
Occurs when the user provids an unrecognized SubCommand
which does not meet the
threshold for being similar enough to an existing subcommand so as to not cause the more
detailed InvalidSubcommand
error.
This error typically happens when passing additional subcommand names to the help
subcommand. Otherwise, the more general UnknownArgument
error is used.
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!["myprog", "help", "nothing"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::UnrecognizedSubcommand);
EmptyValue
Occurs when the user provides an empty value for an option that does not allow empty values.
Examples
let res = App::new("myprog") .arg(Arg::with_name("color") .long("color") .empty_values(false)) .get_matches_from_safe(vec!["myprog", "--color="]); assert!(res.is_err()); assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
ValueValidation
Occurs when the user provides a value for an argument with a custom validation and the value fails that validation.
Examples
fn is_numeric(val: String) -> Result<(), String> { match val.parse::<i64>() { Ok(..) => Ok(()), Err(..) => Err(String::from("Value wasn't a number!")), } } let result = App::new("myprog") .arg(Arg::with_name("num") .validator(is_numeric)) .get_matches_from_safe(vec!["myprog", "NotANumber"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::ValueValidation);
TooManyValues
Occurs when a user provides more values for an argument than were defined by setting
Arg::max_values
.
Examples
let result = App::new("myprog") .arg(Arg::with_name("arg") .multiple(true) .max_values(2)) .get_matches_from_safe(vec!["myprog", "too", "many", "values"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::TooManyValues);
TooFewValues
Occurs when the user provides fewer values for an argument than were defined by setting
Arg::min_values
.
Examples
let result = App::new("myprog") .arg(Arg::with_name("some_opt") .long("opt") .min_values(3)) .get_matches_from_safe(vec!["myprog", "--opt", "too", "few"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::TooFewValues);
WrongNumberOfValues
Occurs when the user provides a different number of values for an argument than what's
been defined by setting Arg::number_of_values
or than was implicitly set by
Arg::value_names
.
Examples
let result = App::new("myprog") .arg(Arg::with_name("some_opt") .long("opt") .takes_value(true) .number_of_values(2)) .get_matches_from_safe(vec!["myprog", "--opt", "wrong"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::WrongNumberOfValues);
ArgumentConflict
Occurs when the user provides two values which conflict with each other and can't be used together.
Examples
let result = App::new("myprog") .arg(Arg::with_name("debug") .long("debug") .conflicts_with("color")) .arg(Arg::with_name("color") .long("color")) .get_matches_from_safe(vec!["myprog", "--debug", "--color"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::ArgumentConflict);
MissingRequiredArgument
Occurs when the user does not provide one or more required arguments.
Examples
let result = App::new("myprog") .arg(Arg::with_name("debug") .required(true)) .get_matches_from_safe(vec!["myprog"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::MissingRequiredArgument);
MissingSubcommand
Occurs when a subcommand is required (as defined by AppSettings::SubcommandRequired
),
but the user does not provide one.
Examples
let err = App::new("myprog") .setting(AppSettings::SubcommandRequired) .subcommand(SubCommand::with_name("test")) .get_matches_from_safe(vec![ "myprog", ]); assert!(err.is_err()); assert_eq!(err.unwrap_err().kind, ErrorKind::MissingSubcommand);
MissingArgumentOrSubcommand
Occurs when either an argument or SubCommand
is required, as defined by
AppSettings::ArgRequiredElseHelp
but the user did not provide one.
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"))) .get_matches_from_safe(vec!["myprog"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::MissingArgumentOrSubcommand);
UnexpectedMultipleUsage
Occurs when the user provides an argument multiple times which has not been set to allow multiple uses.
Examples
let result = App::new("myprog") .arg(Arg::with_name("debug") .long("debug") .multiple(false)) .get_matches_from_safe(vec!["myprog", "--debug", "--debug"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::UnexpectedMultipleUsage);
InvalidUtf8
Occurs when the user provides a value containing invalid UTF-8 for an argument and
AppSettings::StrictUtf8
is set.
Platform Speicific
Non-Windows platforms only (such as Linux, Unix, OSX, etc.)
Examples
let result = App::new("myprog") .setting(AppSettings::StrictUtf8) .arg(Arg::with_name("utf8") .short("u") .takes_value(true)) .get_matches_from_safe(vec![OsString::from("myprog"), OsString::from("-u") OsString::from_vec(vec![0xE9])]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::InvalidUtf8);
HelpDisplayed
Not a true "error" as it means --help
or similar was used. The help message will be sent
to stdout
.
Note: If the help is displayed due to an error (such as missing subcommands) it will
be sent to stderr
instead of stdout
.
Examples
let result = App::new("myprog") .get_matches_from_safe(vec!["myprog", "--help"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::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!["myprog", "--version"]); assert!(result.is_err()); assert_eq!(result.unwrap_err().kind, ErrorKind::VersionDisplayed);
ArgumentNotFound
Occurs when using the value_t!
and values_t!
macros to convert an argument value
into type T
, but the argument you requested wasn't used. I.e. you asked for an argument
with name config
to be converted, but config
wasn't used by the user.
Io
Represents an I/O error, typically while writing to stderr
or stdout
.
Format
Represents an Rust's Format error as part of Display
, typically while writing to
stderr
or stdout
.
Trait Implementations
impl PartialEq for ErrorKind
[src]
fn eq(&self, __arg_0: &ErrorKind) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0
This method tests for !=
.
impl Clone for ErrorKind
[src]
fn clone(&self) -> ErrorKind
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more