Struct DecodeError

pub struct DecodeError {
    pub kind: Box<DecodeErrorKind>,
    pub codec: Codec,
}

An error type for failed decoding for every decoder. Abstracts over the different generic and codec-specific errors.

kind field is used to determine the kind of error that occurred. codec field is used to determine the codec that failed. backtrace field is used to determine the backtrace of the error.

There is Kind::CodecSpecific variant which wraps the codec-specific errors as CodecEncodeError type.

Example

use nom::Needed;
use rasn::{Codec, error::DecodeErrorKind, prelude::*};

#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq)]
#[rasn(delegate)]
struct MyString(pub VisibleString);

fn main() {
    // Hello, World! in decimal bytes with trailing zeros
    // Below sample requires that `backtraces` feature is enabled
    let hello_data = vec![
        13, 145, 151, 102, 205, 235, 16, 119, 223, 203, 102, 68, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0,
    ];
    // Initially parse the first 2 bytes for Error demonstration purposes
    let mut total = 2;

    loop {
        let decoded = Codec::Uper.decode_from_binary::<MyString>(&hello_data[0..hello_data.len().min(total)]);
        match decoded {
            Ok(succ) => {
                println!("Successful decoding!");
                println!("Decoded string: {}", succ.0);
                break;
            }
            Err(e) => {
                // e is DecodeError, kind is boxed
                match *e.kind {
                    DecodeErrorKind::Incomplete { needed } => {
                        println!("Codec error source: {}", e.codec);
                        println!("Error kind: {}", e.kind);
                        // Here you need to know, that VisibleString has width of 7 bits and UPER parses input
                        // as bits, if you want to build logic around it, and feed exactly the correct amount of data.
                        // Usually you might need to just provide one byte at time instead when something is missing, since
                        // inner logic might not be known to you, and data structures can get complex.
                        total += match needed {
                            Needed::Size(n) => {
                                let missing_bytes = n.get() / 7;
                                missing_bytes

                            }
                            _ => {
                                #[cfg(feature = "backtraces")]
                                println!("Backtrace:\n{:?}", e.backtrace);
                                panic!("Unexpected error! {e:?}");
                            }
                        }
                    }
                    k => {
                        #[cfg(feature = "backtraces")]
                        println!("Backtrace:\n{:?}", e.backtrace);
                        panic!("Unexpected error! {k:?}");
                    }
                }
            }
        }
    }
}

The previous will produce something like following:

Codec error: UPER
Error kind: Need more BITS to continue: (Size(83)).
Successful decoding!
Decoded string: Hello, world!

Fields

kind: Box<DecodeErrorKind>

The kind of decoding error received.

codec: Codec

The codec that returned the error.

Implementations

impl DecodeError

pub fn permitted_alphabet_error( reason: PermittedAlphabetError, codec: Codec, ) -> Self

Creates a wrapper around a permitted alphabet error from a given codec.

pub fn size_constraint_not_satisfied( size: Option<usize>, expected: String, codec: Codec, ) -> Self

Creates a wrapper around a size error from a given codec.

pub fn value_constraint_not_satisfied( value: BigInt, expected: Bounded<i128>, codec: Codec, ) -> Self

Creates a wrapper around a value error from a given codec.

pub fn inner_subtype_constraint_not_satisfied( reason: InnerSubtypeConstraintError, codec: Codec, ) -> Self

Creates a wrapper around a inner subtype constraint error from a given codec. This is mainly used by standards.

pub fn discriminant_value_not_found(discriminant: isize, codec: Codec) -> Self

Creates a wrapper around a discriminant value error from a given codec.

pub fn range_exceeds_platform_width( needed: u32, present: u32, codec: Codec, ) -> Self

Creates a wrapper around a range value error from a given codec.

pub fn fixed_string_conversion_failed( tag: Tag, actual: usize, expected: usize, codec: Codec, ) -> Self

Creates a wrapper around a fixed string conversion error from a given codec.

pub fn incorrect_item_number_in_sequence( expected: usize, actual: usize, codec: Codec, ) -> Self

Creates a wrapper around a sequence item error from a given codec.

pub fn integer_overflow(max_width: u32, codec: Codec) -> Self

Creates a wrapper around a integer overflow error from a given codec.

pub fn integer_type_conversion_failed(msg: String, codec: Codec) -> Self

Creates a wrapper around a integer conversion error from a given codec.

pub fn invalid_bit_string(bits: u8, codec: Codec) -> Self

Creates a wrapper around a invalid bit string error from a given codec.

pub fn missing_tag_class_or_value_in_sequence_or_set( class: Class, value: u32, codec: Codec, ) -> Self

Creates a wrapper around a missing tag error from a given codec.

pub fn type_not_extensible(codec: Codec) -> Self

Creates a wrapper around a unexpected non-extensible type error from a given codec.

pub fn parser_fail(msg: String, codec: Codec) -> Self

Creates a wrapper around a parser error from a given codec.

pub fn real_not_supported(codec: Codec) -> Self

Creates a wrapper around using REAL with unsupported codecs.

pub fn required_extension_not_present(tag: Tag, codec: Codec) -> Self

Creates a wrapper around a missing required extension error from a given codec.

pub fn enumeration_index_not_found( index: usize, extended_list: bool, codec: Codec, ) -> Self

Creates a wrapper around a missing enum index error from a given codec.

pub fn choice_index_exceeds_platform_width( needed: u32, present: DecodeError, codec: Codec, ) -> Self

Creates a wrapper around a choice index exceeding platform width error from a given codec.

pub fn length_exceeds_platform_width(msg: String, codec: Codec) -> Self

Creates a wrapper around a length exceeding platform width error from a given codec.

pub fn choice_index_not_found( index: usize, variants: Variants, codec: Codec, ) -> Self

Creates a wrapper around a missing choice index error from a given codec.

pub fn string_conversion_failed(tag: Tag, msg: String, codec: Codec) -> Self

Creates a wrapper around a string conversion error from a given codec.

pub fn unexpected_extra_data(length: usize, codec: Codec) -> Self

Creates a wrapper around unexpected extra data error from a given codec.

pub fn unexpected_empty_input(codec: Codec) -> Self

Creates a wrapper around unexpected empty input error from a given codec.

pub fn assert_length( expected: usize, actual: usize, codec: Codec, ) -> Result<(), DecodeError>

Checks whether the length matches, and returns an error if not.

pub fn from_kind(kind: DecodeErrorKind, codec: Codec) -> Self

Creates a new error from a given decode error kind and codec.

Trait Implementations

impl Debug for DecodeError

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

Formats the value using the given formatter.

impl Display for DecodeError

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

Formats the value using the given formatter.

impl Error for DecodeError

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

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

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 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 Error for DecodeError

fn custom<D: Display>(msg: D, codec: Codec) -> Self

Creates a new general error using msg when decoding ASN.1.

fn incomplete(needed: Needed, codec: Codec) -> Self

Creates a new error about needing more data to finish parsing.

fn exceeds_max_length(length: BigUint, codec: Codec) -> Self

Creates a new error about exceeding the maximum allowed data for a type.

fn missing_field(name: &'static str, codec: Codec) -> Self

Creates a new error about a missing field.

fn no_valid_choice(name: &'static str, codec: Codec) -> Self

Creates a new error about being unable to match any variant in a choice.

fn field_error(name: &'static str, nested: DecodeError, codec: Codec) -> Self

Creates a new error about being unable to decode a field in a compound type, such as a set or sequence.

fn duplicate_field(name: &'static str, codec: Codec) -> Self

Creates a new error about finding a duplicate field.

fn unknown_field(index: usize, tag: Tag, codec: Codec) -> Self

Create a new error about unknown field.

impl From<BerDecodeErrorKind> for DecodeError

fn from(error: BerDecodeErrorKind) -> Self

Converts to this type from the input type.

impl From<CodecDecodeError> for DecodeError

fn from(error: CodecDecodeError) -> Self

Converts to this type from the input type.

impl From<CoerDecodeErrorKind> for DecodeError

fn from(error: CoerDecodeErrorKind) -> Self

Converts to this type from the input type.

impl From<DerDecodeErrorKind> for DecodeError

fn from(error: DerDecodeErrorKind) -> Self

Converts to this type from the input type.

impl From<JerDecodeErrorKind> for DecodeError

fn from(error: JerDecodeErrorKind) -> Self

Converts to this type from the input type.

impl From<OerDecodeErrorKind> for DecodeError

fn from(error: OerDecodeErrorKind) -> Self

Converts to this type from the input type.

impl From<XerDecodeErrorKind> for DecodeError

fn from(error: XerDecodeErrorKind) -> Self

Converts to this type from the input type.