Enum DetectUnrecognized 

pub enum DetectUnrecognized<A, E> {
    Unrecognized(A),
    Error(E),
}

An error type that assists state errors with propagating unrecognized arguments.

When a State doesn’t recognize an argument, it returns the argument it got as a function argument, so that it can be retried elsewhere. This enum provides a container for this function argument. This allows the caller of the state method to opt-in or opt-out of actually receiving this unused argument, depending on if it wants to retry it or not.

This type is mostly used by the debate derives.

Variants

Unrecognized(A)

This argument wasn’t recognized and can be retried

Error(E)

A different error occurred

Trait Implementations

impl<'arg, E> Error<'arg> for DetectUnrecognized<(), E>

where E: Error<'arg>,

fn needs_arg() -> Self

The parameter requires an argument, and none was provided.

fn got_arg(arg: &'arg Arg) -> Self

The parameter is a --switch; it must NOT have a value, and got one.

fn got_additional_instance() -> Self

The argument appeared more times than expected (usually more than once) on the command line

fn invalid_utf8(arg: &'arg Arg) -> Self

The argument wasn’t valid UTF-8 and should be.

fn parse_error(arg: &'arg str, msg: impl Display) -> Self

The argument was valid UTF-8, but it failed to parse into an instance of the type.

fn byte_parse_error(arg: &'arg Arg, msg: impl Display) -> Self

The argument failed to parse into an instance of the type.

fn should_be(argument: &'arg Arg, expected: &'static [&'static str]) -> Self

The argument should be one of the given values (or, possibly, a case insensitive variation)

fn custom(msg: impl Display) -> Self

Something else went wrong

impl<'arg, A, E> Error<'arg, A> for DetectUnrecognized<A, E>

where E: Error<'arg, A>,

type ParameterError = <E as Error<'arg, A>>::ParameterError

Error type for parameter errors (see parameter).

type FlagList = <E as Error<'arg, A>>::FlagList

List of flags for conflicts_with_flags.

fn parameter(field: &'static str, error: Self::ParameterError) -> Self

A parameter type returned an error. This means that the argument was recognized and matched to a specific field, but something went wrong during parsing, such as a letter appearing in a numeric parameter.

fn unrecognized(argument: A) -> Self

An argument was unrecognized. In this case, the Argument can be returned unused inside of Self, so that it can be retried by a different parser. For instance, a subcommand parser could indicate that an argument is unrecognized, and that argument can later be handled as a global argument.

fn flattened(field: &'static str, error: Self) -> Self

There was a state error from another State inside of this one.

fn unknown_subcommand(expected: &'static [&'static str]) -> Self

The positional argument was interpreted as a subcommand, but wasn’t recognized as a known subcommand. The list of known subcommands is given.

fn wrong_subcommand_for_argument( subcommand: &'static str, allowed: &'static [&'static str], ) -> Self

The option was recognized, but it isn’t a valid for this particular subcommand. The current subcommand, along with the list of subcommands that accept this option, are given

fn conflicts_with_flags(flags: Self::FlagList) -> Self

The argument conflicts with the given flags that were already parsed.

fn help_requested(req: HelpRequest) -> Self

This was a request for a usage message. This error doesn’t need to interrupt argument parsing, since it can be useful to have a complete state object to print more contextually useful usage messages.