Enum clap::error::ErrorKind

source ·
#[non_exhaustive]
pub enum ErrorKind {
Show 17 variants InvalidValue, UnknownArgument, InvalidSubcommand, NoEquals, ValueValidation, TooManyValues, TooFewValues, WrongNumberOfValues, ArgumentConflict, MissingRequiredArgument, MissingSubcommand, InvalidUtf8, DisplayHelp, DisplayHelpOnMissingArgumentOrSubcommand, DisplayVersion, Io, Format,
}
Expand description

Command line argument parser kind of error

Variants (Non-exhaustive)§

This enum is marked as non-exhaustive
Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future 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 = Command::new("prog")
    .arg(Arg::new("speed")
        .value_parser(["fast", "slow"]))
    .try_get_matches_from(vec!["prog", "other"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidValue);
§

UnknownArgument

Occurs when a user provides a flag, option, argument or subcommand which isn’t defined.

§Examples

let result = Command::new("prog")
    .arg(arg!(--flag "some flag"))
    .try_get_matches_from(vec!["prog", "--other"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::UnknownArgument);
§

InvalidSubcommand

Occurs when the user provides an unrecognized Subcommand which meets the threshold for being similar enough to an existing subcommand. If it doesn’t meet the threshold, or the ‘suggestions’ feature is disabled, the more general UnknownArgument error is returned.

§Examples

let result = Command::new("prog")
   .subcommand(Command::new("config")
       .about("Used for configuration")
       .arg(Arg::new("config_file")
           .help("The configuration file to use")))
   .try_get_matches_from(vec!["prog", "confi"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidSubcommand);
§

NoEquals

Occurs when the user doesn’t use equals for an option that requires equal sign to provide values.

let res = Command::new("prog")
    .arg(Arg::new("color")
         .action(ArgAction::Set)
         .require_equals(true)
         .long("color"))
    .try_get_matches_from(vec!["prog", "--color", "red"]);
assert!(res.is_err());
assert_eq!(res.unwrap_err().kind(), ErrorKind::NoEquals);
§

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: &str) -> Result<(), String> {
    match val.parse::<i64>() {
        Ok(..) => Ok(()),
        Err(..) => Err(String::from("Value wasn't a number!")),
    }
}

let result = Command::new("prog")
    .arg(Arg::new("num")
         .value_parser(value_parser!(u8)))
    .try_get_matches_from(vec!["prog", "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::num_args.

§Examples

let result = Command::new("prog")
    .arg(Arg::new("arg")
        .num_args(1..=2))
    .try_get_matches_from(vec!["prog", "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::num_args.

§Examples

let result = Command::new("prog")
    .arg(Arg::new("some_opt")
        .long("opt")
        .num_args(3..))
    .try_get_matches_from(vec!["prog", "--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::num_args or than was implicitly set by Arg::value_names.

§Examples

let result = Command::new("prog")
    .arg(Arg::new("some_opt")
        .long("opt")
        .action(ArgAction::Set)
        .num_args(2))
    .try_get_matches_from(vec!["prog", "--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 = Command::new("prog")
    .arg(Arg::new("debug")
        .long("debug")
        .action(ArgAction::SetTrue)
        .conflicts_with("color"))
    .arg(Arg::new("color")
        .long("color")
        .action(ArgAction::SetTrue))
    .try_get_matches_from(vec!["prog", "--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 = Command::new("prog")
    .arg(Arg::new("debug")
        .required(true))
    .try_get_matches_from(vec!["prog"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::MissingRequiredArgument);
§

MissingSubcommand

Occurs when a subcommand is required (as defined by Command::subcommand_required), but the user does not provide one.

§Examples

let err = Command::new("prog")
    .subcommand_required(true)
    .subcommand(Command::new("test"))
    .try_get_matches_from(vec![
        "myprog",
    ]);
assert!(err.is_err());
assert_eq!(err.unwrap_err().kind(), ErrorKind::MissingSubcommand);
§

InvalidUtf8

Occurs when the user provides a value containing invalid UTF-8.

To allow arbitrary data

§Platform Specific

Non-Windows platforms only (such as Linux, Unix, OSX, etc.)

§Examples

let result = Command::new("prog")
   .arg(Arg::new("utf8")
       .short('u')
       .action(ArgAction::Set))
   .try_get_matches_from(vec![OsString::from("myprog"),
                               OsString::from("-u"),
                               OsString::from_vec(vec![0xE9])]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::InvalidUtf8);
§

DisplayHelp

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 = Command::new("prog")
   .try_get_matches_from(vec!["prog", "--help"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::DisplayHelp);
§

DisplayHelpOnMissingArgumentOrSubcommand

Occurs when either an argument or a Subcommand is required, as defined by Command::arg_required_else_help , but the user did not provide one.

§Examples

let result = Command::new("prog")
    .arg_required_else_help(true)
    .subcommand(Command::new("config")
        .about("Used for configuration")
        .arg(Arg::new("config_file")
            .help("The configuration file to use")))
    .try_get_matches_from(vec!["prog"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand);
§

DisplayVersion

Not a true “error” as it means --version or similar was used. The message will be sent to stdout.

§Examples

let result = Command::new("prog")
    .version("3.0")
    .try_get_matches_from(vec!["prog", "--version"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::DisplayVersion);
§

Io

Represents an I/O error. Can occur when writing to stderr or stdout or reading a configuration file.

§

Format

Represents a Format error (which is a part of Display). Typically caused by writing to stderr or stdout.

Implementations§

source§

impl ErrorKind

source

pub fn as_str(self) -> Option<&'static str>

End-user description of the error case, where relevant

Trait Implementations§

source§

impl Clone for ErrorKind

source§

fn clone(&self) -> ErrorKind

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for ErrorKind

source§

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

Formats the value using the given formatter. Read more
source§

impl Display for ErrorKind

source§

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

Formats the value using the given formatter. Read more
source§

impl Hash for ErrorKind

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl PartialEq for ErrorKind

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Copy for ErrorKind

source§

impl Eq for ErrorKind

source§

impl StructuralPartialEq for ErrorKind

Auto Trait Implementations§

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

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

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

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

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.