Enum ParseError

pub enum ParseError<I> {
    Base(I),
    Expected {
        tried: I,
        expected: &'static str,
    },
    Explained {
        tried: I,
        explained: &'static str,
    },
    ExplainedExpected {
        tried: I,
        explained: &'static str,
        expected: &'static str,
    },
    MissingDelimiter {
        opened: I,
        tried: I,
    },
    ExcessiveDepth(I),
    Field(I, String),
    Split(I, String),
    Order(I, String),
    Group(I, String),
    Role(I, String),
    ParseInt {
        tried: I,
        error: ParseIntError,
    },
    ParseFloat {
        tried: I,
        error: ParseFloatError,
    },
    ParseDecimal {
        tried: I,
        error: Error,
    },
    ParseRegex {
        tried: I,
        error: Error,
    },
    RangeError {
        tried: I,
        lower: Bound<u32>,
        upper: Bound<u32>,
    },
    InvalidUnicode {
        tried: I,
    },
    InvalidPath {
        tried: I,
        parent: I,
    },
}

Variants

Base(I)

Expected

Fields

tried: I

expected: &'static str

Explained

Fields

tried: I

explained: &'static str

ExplainedExpected

Fields

tried: I

explained: &'static str

expected: &'static str

MissingDelimiter

Fields

opened: I

tried: I

ExcessiveDepth(I)

Field(I, String)

Split(I, String)

Order(I, String)

Group(I, String)

Role(I, String)

ParseInt

Fields

tried: I

error: ParseIntError

ParseFloat

Fields

tried: I

error: ParseFloatError

ParseDecimal

Fields

tried: I

error: Error

ParseRegex

Fields

tried: I

error: Error

RangeError

Fields

tried: I

lower: Bound<u32>

upper: Bound<u32>

InvalidUnicode

Fields

tried: I

InvalidPath

Fields

tried: I

parent: I

Implementations

impl<I: Clone> ParseError<I>

pub fn tried(&self) -> I

returns the input value where the parser failed.

impl ParseError<&str>

pub fn render_on(&self, input: &str) -> RenderedError

Returns the error represented as a pretty printed string formatted on the original source text.

Trait Implementations

impl<I: Clone> Clone for ParseError<I>

fn clone(&self) -> ParseError<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for ParseError<I>

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

Formats the value using the given formatter.

impl<I> Error for ParseError<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<I> FromExternalError<I, Error> for ParseError<I>

fn from_external_error(input: I, _kind: ErrorKind, e: Error) -> Self

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

impl<I> FromExternalError<I, ParseFloatError> for ParseError<I>

fn from_external_error(input: I, _kind: ErrorKind, e: ParseFloatError) -> Self

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

impl<I> FromExternalError<I, ParseIntError> for ParseError<I>

fn from_external_error(input: I, _kind: ErrorKind, e: ParseIntError) -> Self

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

impl<I> ParseError<I> for ParseError<I>

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

Creates an error from the input position and an ErrorKind

fn append(_: I, _: 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.