Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind<'v> {
    InvalidLength {
        min: Option<u64>,
        max: Option<u64>,
    },
    InvalidChoice {
        choices: Cow<'v, [Cow<'v, str>]>,
    },
    OutOfRange {
        start: Option<isize>,
        end: Option<isize>,
    },
    Validation(Cow<'v, str>),
    Duplicate,
    Missing,
    Unexpected,
    Unknown,
    Custom(Status, Box<dyn Error + Send>),
    Multipart(Error),
    Utf8(Utf8Error),
    Char(ParseCharError),
    Int(ParseIntError),
    Bool(ParseBoolError),
    Float(ParseFloatError),
    Addr(AddrParseError),
    Io(Error),
}

The kind of form error that occurred.

Constructing

An ErrorKind can be constructed directly or via a From of the following types:

• (Option<u64>, Option<u64>) => ErrorKind::InvalidLength
• (Option<ByteUnit>, Option<ByteUnit>) => ErrorKind::InvalidLength
• (Option<isize>, Option<isize>) => ErrorKind::OutOfRange
• &[Cow<'_, str>] or Vec<Cow<'_, str>> => ErrorKind::InvalidChoice
• Utf8Error => ErrorKind::Utf8
• ParseIntError => ErrorKind::Int
• ParseFloatError => ErrorKind::Float
• ParseBoolError => ErrorKind::Bool
• AddrParseError => ErrorKind::Addr
• io::Error => ErrorKind::Io
• Box<dyn std::error::Error + Send => ErrorKind::Custom
• (Status, Box<dyn std::error::Error + Send) => ErrorKind::Custom

Variants (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.

InvalidLength

The value’s length, in bytes, was outside the range [min, max].

Fields

min: Option<u64>

The minimum length required, inclusive.

max: Option<u64>

The maximum length required, inclusive.

InvalidChoice

The value wasn’t one of the valid choices.

Fields

choices: Cow<'v, [Cow<'v, str>]>

The choices that were expected.

OutOfRange

The integer value was outside the range [start, end].

Fields

start: Option<isize>

The start of the acceptable range, inclusive.

end: Option<isize>

The end of the acceptable range, inclusive.

Validation(Cow<'v, str>)

A custom validation routine failed with message .0.

Duplicate

One entity was expected but more than one was received.

Missing

An entity was expected but was not received.

Unexpected

An unexpected entity was received.

Unknown

An unknown entity was received.

Custom(Status, Box<dyn Error + Send>)

A custom error occurred. Status defaults to Status::UnprocessableEntity if one is not directly specified.

Multipart(Error)

An error while parsing a multipart form occurred.

Utf8(Utf8Error)

A string was invalid UTF-8.

Char(ParseCharError)

A value failed to parse as a char.

Int(ParseIntError)

A value failed to parse as an integer.

Bool(ParseBoolError)

A value failed to parse as a boolean.

Float(ParseFloatError)

A value failed to parse as a float.

Addr(AddrParseError)

A value failed to parse as an IP or socket address.

Io(Error)

An I/O error occurred.

Trait Implementations

impl<'v> Debug for ErrorKind<'v>

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

Formats the value using the given formatter.

impl Display for ErrorKind<'_>

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

Formats the value using the given formatter.

impl<'a, 'v: 'a> From<&'static [Cow<'v, str>]> for ErrorKind<'a>

fn from(choices: &'static [Cow<'v, str>]) -> Self

Converts to this type from the input type.

impl<'a, 'v: 'a, const N: usize> From<&'static [Cow<'v, str>; N]> for ErrorKind<'a>

fn from(choices: &'static [Cow<'v, str>; N]) -> Self

Converts to this type from the input type.

impl From<(Option<ByteUnit>, Option<ByteUnit>)> for ErrorKind<'_>

fn from((start, end): (Option<ByteUnit>, Option<ByteUnit>)) -> Self

Converts to this type from the input type.

impl From<(Option<isize>, Option<isize>)> for ErrorKind<'_>

fn from((start, end): (Option<isize>, Option<isize>)) -> Self

Converts to this type from the input type.

impl From<(Option<u64>, Option<u64>)> for ErrorKind<'_>

fn from((min, max): (Option<u64>, Option<u64>)) -> Self

Converts to this type from the input type.

impl<'a> From<(Status, Box<dyn Error + Send>)> for ErrorKind<'a>

fn from((status, e): (Status, Box<dyn Error + Send>)) -> Self

Converts to this type from the input type.

impl<'a> From<AddrParseError> for ErrorKind<'a>

fn from(value: AddrParseError) -> Self

Converts to this type from the input type.

impl<'a> From<Box<dyn Error + Send>> for ErrorKind<'a>

fn from(e: Box<dyn Error + Send>) -> Self

Converts to this type from the input type.

impl<'a> From<Error> for ErrorKind<'a>

fn from(value: Error) -> Self

Converts to this type from the input type.

impl<'a> From<ParseBoolError> for ErrorKind<'a>

fn from(value: ParseBoolError) -> Self

Converts to this type from the input type.

impl<'a> From<ParseCharError> for ErrorKind<'a>

fn from(value: ParseCharError) -> Self

Converts to this type from the input type.

impl<'a> From<ParseFloatError> for ErrorKind<'a>

fn from(value: ParseFloatError) -> Self

Converts to this type from the input type.

impl<'a> From<ParseIntError> for ErrorKind<'a>

fn from(value: ParseIntError) -> Self

Converts to this type from the input type.

impl<'a> From<Utf8Error> for ErrorKind<'a>

fn from(value: Utf8Error) -> Self

Converts to this type from the input type.

impl<'a, 'v: 'a> From<Vec<Cow<'v, str>>> for ErrorKind<'a>

fn from(choices: Vec<Cow<'v, str>>) -> Self

Converts to this type from the input type.

impl IntoOwned for ErrorKind<'_>

type Owned = ErrorKind<'static>

The owned version of the type.

fn into_owned(self) -> Self::Owned

Converts self into an owned version of itself.

impl<'a, 'b> PartialEq<ErrorKind<'b>> for ErrorKind<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.