Struct BerError

pub struct BerError<I: Input> { /* private fields */ }

Implementations

impl<I: Input> BerError<I>

pub const fn new(input: I, inner: InnerError) -> Self

Build a new error

pub const fn input(&self) -> &I

Return the error location

pub fn inner(&self) -> &InnerError

Return the error kind

pub const fn nom_err(input: I, inner_error: InnerError) -> Err<Self>

pub fn convert(input: I) -> impl Fn(InnerError) -> Err<Self>

where I: Clone,

convert an InnerError to a nom::Err::Error(input, inner)

This is usefull when mapping the result of a function returning InnerError inside a parser function (expecting error type Err<Error<I>>).

For ex: header.tag().assert_eq(Tag(0)).map_err(Error::convert(input))?

pub fn convert_into<E: From<Self>>(input: I) -> impl Fn(InnerError) -> Err<E>

where I: Clone,

convert an InnerError to a nom::Err::Error<E> with e: From<Error<I>>

This is similar to Self::convert, but with an Into applied to the result

pub const fn invalid_value(input: I, tag: Tag, msg: String) -> Self

Build an error from the provided invalid value

pub const fn unexpected_tag( input: I, expected: Option<Tag>, actual: Tag, ) -> Self

Build an error from the provided unexpected tag

pub const fn unexpected_class( input: I, expected: Option<Class>, actual: Class, ) -> Self

Build an error from the provided unexpected tag

pub const fn incomplete(input: I, n: Needed) -> Self

Build an Incomplete error from the provided parameters

impl<'i> BerError<Input<'i>>

pub const fn err_input<'a: 'i, 'r>( input: &'r Input<'a>, inner: InnerError, ) -> Self

Build a new BerError from input reference and inner error

pub const fn nom_err_input<'a: 'i, 'r>( input: &'r Input<'a>, inner: InnerError, ) -> Err<Self>

Builda new nom::Err::Error<BerError> from input reference and inner error

pub fn consume(self) -> (Input<'i>, InnerError)

Consume the error and return error location and inner error

Trait Implementations

impl<I: Debug + Input> Debug for BerError<I>

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

Formats the value using the given formatter.

impl<I: Input + Display> Display for BerError<I>

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

Formats the value using the given formatter.

impl<I: Input> Error for BerError<I>

where Self: Debug + Display,

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<'a, 'b> From<(Input<'b>, BerError<Input<'b>>)> for BerError<Input<'a>>

where 'b: 'a,

fn from(value: (Input<'b>, BerError<Input<'b>>)) -> Self

Converts to this type from the input type.

impl<'a, 'b> From<(Input<'b>, Error)> for BerError<Input<'a>>

where 'b: 'a,

fn from(value: (Input<'b>, Error)) -> Self

Converts to this type from the input type.

impl<I: Input> From<BerError<I>> for Error

fn from(value: BerError<I>) -> Self

Converts to this type from the input type.

impl From<Error> for BerError<Input<'_>>

fn from(value: Error) -> Self

Converts to this type from the input type.

impl<I: Input> ParseError<I> for BerError<I>

fn from_error_kind(input: I, kind: ErrorKind) -> Self

Creates an error from the input position and an ErrorKind

fn append(_: I, _z: ErrorKind, other: Self) -> Self

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<I: PartialEq + Input> PartialEq for BerError<I>

fn eq(&self, other: &BerError<I>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<I: Eq + Input> Eq for BerError<I>

impl<I: Input> StructuralPartialEq for BerError<I>