Struct kparse::parser_error::ParserError

pub struct ParserError<C, I> {
    pub code: C,
    pub span: I,
    pub hints: Vec<Hints<C, I>>,
    pub backtrace: Backtrace,
}

Parser error.

Fields

code: C

Error code

span: I

Error span

hints: Vec<Hints<C, I>>

Extra information

backtrace: Backtrace

Implementations

impl<C, I> ParserError<C, I>where C: Code, I: Clone,

pub fn new(code: C, span: I) -> Self

New error.

pub fn with_cause<E>(self, err: E) -> Selfwhere E: Error + 'static,

With a cause.

pub fn with_user_data<Y>(self, user_data: Y) -> Selfwhere Y: 'static,

With user data.

pub fn cause(&self) -> Option<&dyn Error>

Finds the first (single) cause.

pub fn user_data<Y: 'static>(&self) -> Option<&Y>

Finds the first (single) user data.

pub fn error(self) -> Err<Self>

Convert to a nom::Err::Error.

pub fn failure(self) -> Err<Self>

Convert to a nom::Err::Failure.

pub fn append_err(&mut self, other: ParserError<C, I>)

Adds information from the other parser error to this on.

Adds the others code and span as expect values. Adds all the others expect values.

pub fn with_code(self, code: C) -> Self

Convert to a new error code. If the old one differs, it is added to the expect list.

pub fn is_expected(&self, code: C) -> bool

Was this one of the expected errors. The main error code is one of the tested values.

pub fn expect(&mut self, code: C, span: I)

Add an expected code.

pub fn append_expected( &mut self, exp_iter: impl Iterator<Item = SpanAndCode<C, I>> )

Adds some expected codes.

pub fn iter_expected(&self) -> impl Iterator<Item = SpanAndCode<C, I>> + '_

Returns the expected codes.

Beware

The main error code is not included here.

pub fn suggest(&mut self, code: C, span: I)

Add an suggested code.

pub fn is_suggested(&self, code: C) -> bool

Was this one of the expected errors. The main error code is one of the tested values.

pub fn append_suggested( &mut self, sug_iter: impl Iterator<Item = SpanAndCode<C, I>> )

Adds some suggested codes.

pub fn iter_suggested(&self) -> impl Iterator<Item = SpanAndCode<C, I>> + '_

Returns the suggested codes.

Trait Implementations

impl<C, I> AppendParserError<Err<ParserError<C, I>>> for ParserError<C, I>where C: Code, I: Clone,

type Output = Result<(), Err<ParserError<C, I>>>

Result of the append. Usually (), but for nom::Err::Incomplete the error is not appended but passed through.

fn append(&mut self, err: Err<ParserError<C, I>>) -> Self::Output

Appends

impl<C, I> AppendParserError<ParserError<C, I>> for Err<ParserError<C, I>>where C: Code, I: Clone,

type Output = Result<(), Err<ParserError<C, I>>>

Result of the append. Usually (), but for nom::Err::Incomplete the error is not appended but passed through.

fn append(&mut self, err: ParserError<C, I>) -> Self::Output

Appends

impl<C, I> AppendParserError<ParserError<C, I>> for Option<ParserError<C, I>>where C: Code, I: Clone,

type Output = ()

Result of the append. Usually (), but for nom::Err::Incomplete the error is not appended but passed through.

fn append(&mut self, err: ParserError<C, I>)

Appends

impl<C, I> AppendParserError for ParserError<C, I>where C: Code, I: Clone,

type Output = ()

Result of the append. Usually (), but for nom::Err::Incomplete the error is not appended but passed through.

fn append(&mut self, err: ParserError<C, I>)

Appends

impl<C, I> Debug for ParserError<C, I>where C: Code, I: Clone + Debug + SpanFragment + InputTake + InputLength + InputIter,

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

Formats the value using the given formatter.

impl<C, I> Display for ParserError<C, I>where C: Code, I: Clone + Debug + SpanFragment + InputTake + InputLength + InputIter,

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

Formats the value using the given formatter.

impl<C, I> ErrOrNomErr for ParserError<C, I>where C: Code, I: Clone + Debug + SpanFragment + InputTake + InputLength + InputIter,

type WrappedError = ParserError<C, I>

The base error type.

fn wrap(self) -> Err<Self::WrappedError>

Converts self to a nom::Err wrapped error.

impl<C, I> Error for ParserError<C, I>where C: Code, I: Clone + Debug + SpanFragment + InputTake + InputLength + InputIter,

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, 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<C, I> From<TokenizerError<C, I>> for ParserError<C, I>where C: Code, I: Clone,

fn from(value: TokenizerError<C, I>) -> Self

Converts to this type from the input type.

impl<C, I> KParseError<C, I> for ParserError<C, I>where C: Code, I: Clone + Debug + SpanFragment + InputTake + InputLength + InputIter,

type WrappedError = ParserError<C, I>

The base error type.

fn from(code: C, span: I) -> Self

Create a matching error.

fn with_code(self, code: C) -> Self

Changes the error code.

fn code(&self) -> Option<C>

Returns the error code if self is Result::Err and it’s not nom::Err::Incomplete.

fn span(&self) -> Option<I>

Returns the error span if self is Result::Err and it’s not nom::Err::Incomplete.

fn err(&self) -> Option<&Self::WrappedError>

Returns the error if self is Result::Err and it’s not nom::Err::Incomplete.

fn parts(&self) -> Option<(C, I, &Self::WrappedError)>

Returns all the parts if self is Result::Err and it’s not nom::Err::Incomplete.

impl<C, I> ParseError<I> for ParserError<C, I>where C: Code, I: Clone,

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

Combines two parser errors.

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

Creates an error from the input position and an ErrorKind

fn append(_input: I, _kind: 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, _ch: char) -> Self

Creates an error from an input position and an expected character