Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind {
    Syntax,
    EndOfFile,
    LimitExceeded,
    InvalidType,
    InvalidValue,
    OutOfRange,
    WrongLength,
    MissingField,
    UnknownField,
    UnknownVariant,
    DuplicateKey,
    UnsupportedType,
    InvalidState,
    Configuration,
    Io,
    Custom,
}

Describes the kind of error.

The kind determines the ErrorCategory of an error (see Error::category): the formats fail with Syntax, EndOfFile and LimitExceeded if the input is not well-formed, the values with the kinds of the Data category if it is well-formed but does not fit them.

More kinds may be added in the future.

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.

Syntax

The input is not well-formed.

This covers what the grammar of the format rejects (including data after the end of the input and input that is not validly encoded) and documents that are invalid in the format (like an unknown alias in YAML or rows of different lengths in CSV).

EndOfFile

The input ended before the value was complete or is empty.

LimitExceeded

A limit was exceeded (see Limits), like the depth of nesting or the length of the input.

InvalidType

A value has a type that is not expected (like a string where a number is expected).

InvalidValue

A value has the type that is expected but is invalid (like text that is not a number where a number is expected, or a value that a validator rejects).

OutOfRange

A number is out of the range of the type it’s converted to.

WrongLength

A sequence or bytes have a length that is not expected.

MissingField

A field (or the tag of an enum) is missing.

UnknownField

A field is not known (see #[deser(deny_unknown_fields)]).

UnknownVariant

A variant of an enum is not known, or no variant of an untagged enum matches.

DuplicateKey

A key is given more than once (see DuplicateKeys).

UnsupportedType

A type or value cannot be represented: the format does not support it, or the type cannot be deserialized from what the format provides (like a &str from a string that is not borrowed).

InvalidState

An API is used in a way that is not supported, for instance a stream that failed is used again or a serializer receives events that do not form a value.

Configuration

deser is set up wrongly, for instance the variants of an open enum are not registered or two of them have the same name. These are bugs in the program, not problems of the input.

Io

Reading or writing failed (see deser::io). The IO error is the source of the error.

Custom

An error which has none of the other kinds.

The category of these errors depends on where they come from (see Error::category).

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ErrorKind

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Eq for ErrorKind

impl PartialEq for ErrorKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ErrorKind