Enum clap::ErrorKind

source ·

pub enum ErrorKind {
Show 20 variants    InvalidValue,
    UnknownArgument,
    InvalidSubcommand,
    UnrecognizedSubcommand,
    EmptyValue,
    ValueValidation,
    TooManyValues,
    TooFewValues,
    WrongNumberOfValues,
    ArgumentConflict,
    MissingRequiredArgument,
    MissingSubcommand,
    MissingArgumentOrSubcommand,
    UnexpectedMultipleUsage,
    InvalidUtf8,
    HelpDisplayed,
    VersionDisplayed,
    ArgumentNotFound,
    Io,
    Format,
}

Expand description

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);

[Arg::number_of_values] [Arg::number_of_values]: ./struct.Arg.html#method.number_of_values [Arg::value_names]: ./struct.Arg.html#method.value_names

§

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. value_t!: ./macro.value_t!.html values_t!: ./macro.values_t!.html

§

Io

Represents an [I/O error], typically while writing to stderr or stdout. [I/O error]: https://doc.rust-lang.org/std/io/struct.Error.html

§

Format

Represents an Rust’s [Format error] as part of Display , typically while writing to stderr or stdout. Display: https://doc.rust-lang.org/std/fmt/trait.Display.html [Format error]: https://doc.rust-lang.org/std/fmt/struct.Error.html

Enum clap::ErrorKindCopy item path

Variants§

InvalidValue

§Examples

UnknownArgument

§Examples

InvalidSubcommand

§Examples

UnrecognizedSubcommand

§Examples

EmptyValue

§Examples

ValueValidation

§Examples

TooManyValues

§Examples

TooFewValues

§Examples

WrongNumberOfValues

§Examples

ArgumentConflict

§Examples

MissingRequiredArgument

§Examples

MissingSubcommand

§Examples

MissingArgumentOrSubcommand

§Examples

UnexpectedMultipleUsage

§Examples

InvalidUtf8

§Platform Speicific

§Examples

HelpDisplayed

§Examples

VersionDisplayed

§Examples

ArgumentNotFound

Io

Format

Trait Implementations§

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

fn clone_from(&mut self, source: &Self)

impl Debug for ErrorKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl PartialEq for ErrorKind

fn eq(&self, other: &ErrorKind) -> bool

fn ne(&self, other: &Rhs) -> bool

impl Copy for ErrorKind

impl StructuralPartialEq for ErrorKind

Auto Trait Implementations§

impl Freeze for ErrorKind

impl RefUnwindSafe for ErrorKind

impl Send for ErrorKind

impl Sync for ErrorKind

impl Unpin for ErrorKind

impl UnwindSafe for ErrorKind

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

default unsafe fn clone_to_uninit(&self, dst: *mut T)

impl<T> CloneToUninit for Twhere T: Copy,

unsafe fn clone_to_uninit(&self, dst: *mut T)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Enum clap::ErrorKind

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T> CloneToUninit for T
where T: Copy,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,