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::Codec;
use rasn::error::DecodeErrorKind;
use rasn::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>

codec: Codec

Implementations

impl DecodeError

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

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

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

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

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

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

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

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

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

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

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

pub fn type_not_extensible(codec: Codec) -> Self

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

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

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

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

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

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

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

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

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

pub fn unexpected_empty_input(codec: Codec) -> Self

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

pub fn map_nom_err<T: Debug>(error: Err<Error<T>>, codec: Codec) -> DecodeError

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

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