Enum der_parser::error::Error

pub enum Error {
    BerTypeError,
    BerValueError,
    InvalidLength,
    InvalidValue {
        tag: Tag,
        msg: String,
    },
    InvalidTag,
    UnknownTag(u32),
    UnexpectedTag {
        expected: Option<Tag>,
        actual: Tag,
    },
    UnexpectedClass {
        expected: Option<Class>,
        actual: Class,
    },
    IndefiniteLengthUnexpected,
    ConstructExpected,
    ConstructUnexpected,
    IntegerTooLarge,
    IntegerNegative,
    BerMaxDepth,
    StringInvalidCharset,
    InvalidDateTime,
    DerConstraintFailed(DerConstraint),
    LifetimeError,
    Unsupported,
    Incomplete(Needed),
    NomError(ErrorKind),
}

The error type for operations of the FromBer, FromDer, and associated traits.

Variants

BerTypeError

BER object does not have the expected type

BerValueError

BER object does not have the expected value

InvalidLength

Invalid Length

InvalidValue

Fields

tag: Tag

msg: String

Invalid Value when parsing object with tag {tag:?} {msg:}

InvalidTag

Invalid Tag

UnknownTag(u32)

Unknown tag: {0:?}

UnexpectedTag

Fields

expected: Option<Tag>

actual: Tag

Unexpected Tag (expected: {expected:?}, actual: {actual:?})

UnexpectedClass

Fields

expected: Option<Class>

actual: Class

Unexpected Class (expected: {expected:?}, actual: {actual:?})

IndefiniteLengthUnexpected

Indefinite length not allowed

ConstructExpected

DER object was expected to be constructed (and found to be primitive)

ConstructUnexpected

DER object was expected to be primitive (and found to be constructed)

IntegerTooLarge

Integer too large to fit requested type

IntegerNegative

BER integer is negative, while an unsigned integer was requested

BerMaxDepth

BER recursive parsing reached maximum depth

StringInvalidCharset

Invalid encoding or forbidden characters in string

InvalidDateTime

Invalid Date or Time

DerConstraintFailed(DerConstraint)

DER Failed constraint

LifetimeError

Requesting borrowed data from a temporary object

Unsupported

Feature is not yet implemented

Incomplete(Needed)

incomplete data, missing: {0:?}

NomError(ErrorKind)

nom error: {0:?}

Implementations

impl Error

pub const fn invalid_value(tag: Tag, msg: String) -> Error

Build an error from the provided invalid value

pub const fn unexpected_class(expected: Option<Class>, actual: Class) -> Error

Build an error from the provided unexpected class

pub const fn unexpected_tag(expected: Option<Tag>, actual: Tag) -> Error

Build an error from the provided unexpected tag

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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

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, demand: &mut Demand<'a>)

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

Provides type based access to context intended for error reports.

impl From<Err<Error>> for Error

fn from(e: Err<Error>) -> Error

Converts to this type from the input type.

impl From<FromUtf16Error> for Error

fn from(_: FromUtf16Error) -> Error

Converts to this type from the input type.

impl From<FromUtf8Error> for Error

fn from(_: FromUtf8Error) -> Error

Converts to this type from the input type.

impl From<Utf8Error> for Error

fn from(_: Utf8Error) -> Error

Converts to this type from the input type.

impl<'a> FromBer<'a, Error> for Header<'a>

fn from_ber(bytes: &'a [u8]) -> Result<(&'a [u8], Header<'a>), Err<Error>>

Attempt to parse input bytes into a BER object

impl<'a> FromDer<'a, Error> for Header<'a>

fn from_der(bytes: &'a [u8]) -> Result<(&'a [u8], Header<'a>), Err<Error>>

Attempt to parse input bytes into a DER object (enforcing constraints)

impl<I, E> FromExternalError<I, E> for Error

fn from_external_error(_input: I, kind: ErrorKind, _e: E) -> Error

Creates a new error from an input position, an ErrorKind indicating the wrapping parser, and an external error

impl<'a> ParseError<&'a [u8]> for Error

fn from_error_kind(_input: &'a [u8], kind: ErrorKind) -> Error

Creates an error from the input position and an ErrorKind

fn append(_input: &'a [u8], kind: ErrorKind, _other: Error) -> Error

Combines an existing error with a new one created from the input position and an ErrorKind. This is useful when backtracking through a parse tree, accumulating error context on the way

fn from_char(input: I, _: char) -> Self

Creates an error from an input position and an expected character

fn or(self, other: Self) -> Self

Combines two existing errors. This function is used to compare errors generated in various branches of alt.

impl PartialEq<Error> for Error

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Error

impl StructuralEq for Error

impl StructuralPartialEq for Error