Enum DecodeErrorKind 

#[non_exhaustive]
pub enum DecodeErrorKind {
    PermittedAlphabetError {
        reason: PermittedAlphabetError,
    },
    SizeConstraintNotSatisfied {
        size: Option<usize>,
        expected: String,
    },
    ValueConstraintNotSatisfied {
        value: BigInt,
        expected: Bounded<i128>,
    },
    InnerSubtypeConstraintNotSatisfied {
        reason: InnerSubtypeConstraintError,
    },
    CodecSpecific {
        inner: CodecDecodeError,
    },
    EnumerationIndexNotFound {
        index: usize,
        extended_list: bool,
    },
    ChoiceIndexNotFound {
        index: usize,
        variants: Variants,
    },
    ChoiceIndexExceedsPlatformWidth {
        needed: u32,
        present: DecodeError,
    },
    Custom {
        msg: String,
    },
    DiscriminantValueNotFound {
        discriminant: isize,
    },
    DuplicateField {
        name: &'static str,
    },
    ExceedsMaxLength {
        length: BigUint,
    },
    LengthExceedsPlatformWidth {
        msg: String,
    },
    FieldError {
        name: &'static str,
        nested: Box<DecodeError>,
    },
    Incomplete {
        needed: Needed,
    },
    Eof,
    IncorrectItemNumberInSequence {
        expected: usize,
        actual: usize,
    },
    IntegerOverflow {
        max_width: u32,
    },
    IntegerTypeConversionFailed {
        msg: String,
    },
    InvalidRealEncoding,
    RealNotSupported,
    InvalidBitString {
        bits: u8,
    },
    InvalidBool {
        value: u8,
    },
    ZeroLengthOfLength,
    MismatchedLength {
        expected: usize,
        actual: usize,
    },
    MissingField {
        name: &'static str,
    },
    MissingTagClassOrValueInSequenceOrSet {
        class: Class,
        value: u32,
    },
    RangeExceedsPlatformWidth {
        needed: u32,
        present: u32,
    },
    RequiredExtensionNotPresent {
        tag: Tag,
    },
    Parser {
        msg: String,
    },
    StringConversionFailed {
        tag: Tag,
        msg: String,
    },
    FixedStringConversionFailed {
        tag: Tag,
        expected: usize,
        actual: usize,
    },
    NoValidChoice {
        name: &'static str,
    },
    TypeNotExtensible,
    UnexpectedExtraData {
        length: usize,
    },
    UnknownField {
        index: usize,
        tag: Tag,
    },
    UnexpectedEmptyInput,
    ExceedsMaxParseDepth,
}

DecodeError kinds which are common for all codecs.

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.

PermittedAlphabetError

Permitted alphabet constraint wasn’t satisfied.

Fields

reason: PermittedAlphabetError

The reason the constraint wasn’t satisfied.

SizeConstraintNotSatisfied

Size constraint wasn’t satisfied.

Fields

size: Option<usize>

Actual sie of the data

expected: String

Expected size by the constraint

ValueConstraintNotSatisfied

Value constraint wasn’t satisfied.

Fields

value: BigInt

Actual value of the data

expected: Bounded<i128>

Expected value by the constraint

InnerSubtypeConstraintNotSatisfied

Inner subtype constraint not satisfied.

Fields

reason: InnerSubtypeConstraintError

The reason the constraint wasn’t satisfied.

CodecSpecific

Codec specific error.

Fields

inner: CodecDecodeError

The inner error type.

EnumerationIndexNotFound

Enumeration index didn’t match any variant.

Fields

index: usize

The found index of the enumerated variant.

extended_list: bool

Whether the index was checked from the extended variants.

ChoiceIndexNotFound

Choice index didn’t match any variant.

Fields

index: usize

The found index of the choice variant.

variants: Variants

The variants checked for presence.

ChoiceIndexExceedsPlatformWidth

Choice index exceeds maximum possible address width.

Fields

needed: u32

Amount of bytes needed.

present: DecodeError

Inner error

Custom

Uncategorised error.

Fields

msg: String

The error’s message.

DiscriminantValueNotFound

Discriminant index didn’t match any variant.

Fields

discriminant: isize

The found value of the discriminant

DuplicateField

Duplicate fields found.

Fields

name: &'static str

The field’s name.

ExceedsMaxLength

Exceeds maxmium allowed length.

Fields

length: BigUint

The maximum length.

LengthExceedsPlatformWidth

More than usize::MAX number of data requested.

Fields

msg: String

The specific message of the length error.

FieldError

An error when decoding a field in a constructed type.

Fields

name: &'static str

The field’s name.

nested: Box<DecodeError>

The underlying error type.

Incomplete

Input is provided as BIT slice for nom in UPER/APER. On BER/CER/DER/OER/COER it is a BYTE slice. Hence, needed field can describe either bits or bytes depending on the codec.

Fields

needed: Needed

Amount of bits/bytes needed.

Eof

Encountered EOF when decoding.

IncorrectItemNumberInSequence

Invalid item number in sequence.

Fields

expected: usize

The expected item number.

actual: usize

The actual item number.

IntegerOverflow

Integer conversion overflow.

Fields

max_width: u32

The maximum integer width.

IntegerTypeConversionFailed

Integer conversion failure.

Fields

msg: String

The reason the conversion failed.

InvalidRealEncoding

Real conversion failure.

RealNotSupported

Decoder doesn’t support REAL

InvalidBitString

BitString contains an invalid amount of unused bits.

Fields

bits: u8

The amount of invalid bits.

InvalidBool

BOOL value is not 0 or 0xFF.

Fields

value: u8

The invalid bool value.

ZeroLengthOfLength

Length of Length cannot be zero.

MismatchedLength

The length does not match what was expected.

Fields

expected: usize

The expected length.

actual: usize

The actual length.

MissingField

Missing field in a sequence.

Fields

name: &'static str

The field’s name.

MissingTagClassOrValueInSequenceOrSet

When there is a mismatch between the expected and actual tag class or value.

Fields

class: Class

The tag’s class.

value: u32

The tag’s value.

RangeExceedsPlatformWidth

The range of the integer exceeds the platform width.

Fields

needed: u32

Amount of bytes needed.

present: u32

Amount of bytes needed.

RequiredExtensionNotPresent

A specific required extension not present.

Fields

tag: Tag

The tag of the required extension.

Parser

General error when parsing data.

Fields

msg: String

The error’s message.

StringConversionFailed

General error for failed ASN.1 string conversion from bytes.

Fields

tag: Tag

Universal tag of the string type.

msg: String

The error’s message.

FixedStringConversionFailed

General error for failed ASN.1 fixed-sized string conversion from bytes.

Fields

tag: Tag

Tag of the string type.

expected: usize

Expected length

actual: usize

Actual length

NoValidChoice

An error when the choice cannot be created from the given variant.

Fields

name: &'static str

The field’s name.

TypeNotExtensible

An error when the type is not extensible when it should.

UnexpectedExtraData

Unexpected extra data found.

Fields

length: usize

The amount of garbage data.

UnknownField

An error when a unknown field is found when decoding sequence.

Fields

index: usize

Index of the field.

tag: Tag

Tag of the field.

UnexpectedEmptyInput

An error when there should be more data but it is not present.

ExceedsMaxParseDepth

An error when the decoder exceeds maximum allowed parse depth.

Trait Implementations

impl Debug for DecodeErrorKind

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

Formats the value using the given formatter.

impl Display for DecodeErrorKind

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

Formats the value using the given formatter.

impl Error for DecodeErrorKind

where Self: Debug + Display,

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl ErrorCompat for DecodeErrorKind

fn backtrace(&self) -> Option<&Backtrace>

Returns a Backtrace that may be printed.

fn iter_chain(&self) -> ChainCompat<'_, '_>

where Self: AsErrorSource,

Returns an iterator for traversing the chain of errors, starting with the current error and continuing with recursive calls to Error::source.