Struct rasn::error::EncodeError

pub struct EncodeError {
    pub kind: Box<EncodeErrorKind>,
    pub codec: Codec,
    pub backtrace: Backtrace,
}

An error type for failed encoding for every encoder. 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 rasn::prelude::*;
use rasn::error::{EncodeErrorKind, strings::PermittedAlphabetError};
use rasn::codec::Codec;

#[derive(AsnType, Clone, Debug, Decode, Encode, PartialEq)]
#[rasn(delegate, from("a..z"))]
struct MyConstrainedString (
    VisibleString,
);

fn main() {
    // Below sample requires that `backtraces` feature is enabled

    let constrained_str = MyConstrainedString(VisibleString::try_from("abcD").unwrap());
    let encoded = Codec::Uper.encode_to_binary(&constrained_str);
    match encoded {
        Ok(succ) => {
            println!("Successful encoding!");
            dbg!(succ);
        }
        Err(e) => {
            // e is EncodeError, Kind is boxed
            match *e.kind {
                EncodeErrorKind::AlphabetConstraintNotSatisfied {
                    reason: PermittedAlphabetError::CharacterNotFound {character },
                } => {
                    println!("Codec: {}", e.codec);
                    println!("Character {} not found from the permitted list.",
                             char::from_u32(character).unwrap());
                    #[cfg(feature = "backtraces")]
                    println!("Backtrace:\n{}", e.backtrace);
                }
                _ => {
                    panic!("Unexpected error!");
                }
            }
        }
    }
    // Should print ->
    //
    // Codec: UPER
    // Character D not found from the permitted list.
    // Backtrace: ...

}

Fields

kind: Box<EncodeErrorKind>

codec: Codec

backtrace: Backtrace

Implementations

impl EncodeError

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

pub fn check_length( length: usize, expected: &Size, codec: Codec ) -> Result<(), Self>

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

An error for failed conversion from BitInt or BigUint to primitive integer types

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

pub fn variant_not_in_choice(codec: Codec) -> Self

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

Trait Implementations

impl Debug for EncodeError

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

Formats the value using the given formatter.

impl Display for EncodeError

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

Formats the value using the given formatter.

impl Error for EncodeError

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

Creates a new general error using msg and current codec when encoding ASN.1.

impl From<BerEncodeErrorKind> for EncodeError

fn from(error: BerEncodeErrorKind) -> Self

Converts to this type from the input type.

impl From<CodecEncodeError> for EncodeError

fn from(error: CodecEncodeError) -> Self

Converts to this type from the input type.

impl From<JerEncodeErrorKind> for EncodeError

fn from(error: JerEncodeErrorKind) -> Self

Converts to this type from the input type.