Struct Error

Source

pub struct Error<F = RichFormatter>where
    F: ErrorFormatter,
{ /* private fields */ }

Expand description

Command Line Argument Parser Error

See Command::error to create an error.

Implementations§

Source §

impl<F> Error<F>
where F: ErrorFormatter,

Source

pub fn raw(kind: ErrorKind, message: impl Display) -> Error<F>

Create an unformatted error

This is for you need to pass the error up to a place that has access to the Command at which point you can call Error::format.

Prefer Command::error for generating errors.

Source

pub fn format(self, cmd: &mut Command) -> Error<F>

Format the existing message with the Command’s context

Source

pub fn new(kind: ErrorKind) -> Error<F>

Create an error with a pre-defined message

§Example


let cmd = clap::Command::new("prog");

let mut err = clap::Error::new(ErrorKind::ValueValidation)
    .with_cmd(&cmd);
err.insert(ContextKind::InvalidArg, ContextValue::String("--foo".to_owned()));
err.insert(ContextKind::InvalidValue, ContextValue::String("bar".to_owned()));

err.print();

Source

pub fn with_cmd(self, cmd: &Command) -> Error<F>

Apply Command’s formatting to the error

Generally, this is used with Error::new

Source

pub fn apply<EF>(self) -> Error<EF>
where EF: ErrorFormatter,

Apply an alternative formatter to the error

§Example

let cmd = Command::new("foo")
    .arg(Arg::new("input").required(true));
let matches = cmd
    .try_get_matches_from(["foo", "input.txt"])
    .map_err(|e| e.apply::<KindFormatter>())
    .unwrap_or_else(|e| e.exit());

Source

pub fn kind(&self) -> ErrorKind

Type of error for programmatic processing

Source

pub fn context(&self) -> impl Iterator<Item = (ContextKind, &ContextValue)>

Additional information to further qualify the error

Source

pub fn get(&self, kind: ContextKind) -> Option<&ContextValue>

Lookup a piece of context

Source

pub fn insert( &mut self, kind: ContextKind, value: ContextValue, ) -> Option<ContextValue>

Insert a piece of context

Source

pub fn use_stderr(&self) -> bool

Should the message be written to stdout or not?

Source

pub fn exit_code(&self) -> i32

Returns the exit code that .exit will exit the process with.

When the error’s kind would print to stderr this returns 2, else it returns 0.

Source

pub fn exit(&self) -> !

Prints the error and exits.

Depending on the error kind, this either prints to stderr and exits with a status of 2 or prints to stdout and exits with a status of 0.

Source

pub fn print(&self) -> Result<(), Error>

Prints formatted and colored error to stdout or stderr according to its error kind

§Example

use clap::Command;

match Command::new("Command").try_get_matches() {
    Ok(matches) => {
        // do_something
    },
    Err(err) => {
        err.print().expect("Error writing Error");
        // do_something
    },
};

Source

pub fn render(&self) -> StyledStr

Render the error message to a StyledStr.

§Example

use clap::Command;

match Command::new("Command").try_get_matches() {
    Ok(matches) => {
        // do_something
    },
    Err(err) => {
        let err = err.render();
        println!("{err}");
        // do_something
    },
};