Enum ParserError 

pub enum ParserError {
    Leaf {
        context: Vec<&'static str>,
    },
    Inter {
        context: Vec<&'static str>,
        source: Box<ParserError>,
    },
    Other {
        context: Vec<&'static str>,
        source: Box<dyn Error + Sync + Send + 'static>,
    },
}

Variants

Leaf

Fields

context: Vec<&'static str>

Inter

Fields

context: Vec<&'static str>

source: Box<ParserError>

Other

Fields

context: Vec<&'static str>

source: Box<dyn Error + Sync + Send + 'static>

Trait Implementations

impl<I: Stream> AddContext<I> for ParserError

fn add_context( self, _input: &I, _token_start: &<I as Stream>::Checkpoint, c: &'static str, ) -> Self

Append to an existing error custom data

impl Debug for ParserError

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

Formats the value using the given formatter.

impl Display for ParserError

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

Formats the value using the given formatter.

impl Error for ParserError

where Self: Debug + Display,

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 source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

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 ErrorCompat for ParserError

fn backtrace(&self) -> Option<&Backtrace>

Returns a Backtrace that may be printed.

fn iter_chain(&self) -> ChainCompat<'_, '_>

where Self: AsErrorSource,

Returns an iterator for traversing the chain of errors, starting with the current error and continuing with recursive calls to Error::source.

impl ErrorConvert<ParserError> for ParserError

fn convert(self) -> ParserError

Transform to another error type

impl<I> From<ParseError<I, ParserError>> for ParserError

fn from(value: ParseError<I, ParserError>) -> Self

Converts to this type from the input type.

impl<I, E: Error + Send + Sync + 'static> FromExternalError<I, E> for ParserError

fn from_external_error(_: &I, e: E) -> Self

Like ParserError::from_input but also include an external error.

impl<I: Stream> ParserError<I> for ParserError

type Inner = ParserError

Generally, Self

fn append(self, _: &I, _: &<I as Stream>::Checkpoint) -> Self

Like ParserError::from_input but merges it with the existing error.

fn from_input(_input: &I) -> Self

Creates an error from the input position

fn into_inner(self) -> Result<Self::Inner, Self>

Unwrap the mode, returning the underlying error, if present

fn assert(input: &I, _message: &'static str) -> Self

where I: Debug,

Process a parser assertion

fn incomplete(input: &I, _needed: Needed) -> Self

There was not enough data to determine the appropriate action

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

Combines errors from two different parse branches.

fn is_backtrack(&self) -> bool

Is backtracking and trying new parse branches allowed?

fn is_incomplete(&self) -> bool

Is more data Needed

fn needed(&self) -> Option<Needed>

Extract the Needed data, if present