Struct kparse::token_error::TokenizerError

pub struct TokenizerError<C, I> {
    pub code: C,
    pub span: I,
}

Shorter error type for the tokenizer stage. Nom parsers fail often, so it’s good to keep this minimal.

Fields

code: C

Error code

span: I

Error span

Implementations

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

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

New error.

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

Replaces the information with the other error. Unless the other contains only the generic NOM_ERROR.

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 error(self) -> Err<Self>

Convert to a nom::Err::Error.

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

Convert to a nom::Err::Failure.

Trait Implementations

impl<C, I> Debug for TokenizerError<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 TokenizerError<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 TokenizerError<C, I>where C: Code, I: Clone + Debug + SpanFragment + InputTake + InputLength + InputIter,

type WrappedError = TokenizerError<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 TokenizerError<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 TokenizerError<C, I>where C: Code, I: Clone + Debug + SpanFragment + InputTake + InputLength + InputIter,

type WrappedError = TokenizerError<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 TokenizerError<C, I>where C: Code, I: Clone + Debug + InputTake + InputLength + InputIter,

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, _char: 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.