Enum ParserError

pub enum ParserError {
    UnsupportedRequirement(Requirement),
    ParseError(ErrorKind, String),
    IncompleteInput(Needed),
    ExpectedIdentifier,
    ExpectedToken(Token, Range<usize>, Option<Vec<(Result<Token, ParserError>, String)>>),
    ExpectedFloat,
    ExpectedInteger,
    LexerError,
    ExpectedEndOfInput,
    UnknownError,
}

A PDDL parser error

Variants

UnsupportedRequirement(Requirement)

The PDDL file contains an unsupported requirement (e.g. :fluents). See the Requirement section of the README.md for a list of supported requirements.

ParseError(ErrorKind, String)

A generic parse error.

IncompleteInput(Needed)

An incomplete input error. This is returned by the parser when it needs more input to continue parsing.

ExpectedIdentifier

The parser expected an identifier, but found something else.

ExpectedToken(Token, Range<usize>, Option<Vec<(Result<Token, ParserError>, String)>>)

The parser expected a token, but found something else.

ExpectedFloat

The parser expected a float, but found something else.

ExpectedInteger

The parser expected an integer, but found something else.

LexerError

The lexer encountered an error. This is returned by the lexer when it encounters an invalid token.

ExpectedEndOfInput

The parser expected the end of input, but there was more input. This is returned by the parser when it encounters more input after the end of the PDDL file.

UnknownError

An unknown error. Default error variant. This should never be returned.

Trait Implementations

impl Clone for ParserError

fn clone(&self) -> ParserError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserError

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

Formats the value using the given formatter.

impl Default for ParserError

fn default() -> ParserError

Returns the “default value” for a type.

impl Display for ParserError

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

Formats the value using the given formatter.

impl Error for ParserError

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 From<Err<ParserError>> for ParserError

fn from(err: Err<ParserError>) -> Self

Converts to this type from the input type.

impl From<ParseFloatError> for ParserError

fn from(_: ParseFloatError) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for ParserError

fn from(_: ParseIntError) -> Self

Converts to this type from the input type.

impl<I: ToString> ParseError<I> for ParserError

fn from_error_kind(input: I, kind: 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.

impl<'a> Parser<TokenStream<'a>, &'a str, ParserError> for Token

fn parse( &mut self, input: TokenStream<'a>, ) -> IResult<TokenStream<'a>, &'a str, ParserError>

A parser takes in input type, and returns a Result containing either the remaining input and the output value, or an error

fn map<G, O2>(self, g: G) -> Map<Self, G, O>

where G: Fn(O) -> O2, Self: Sized,

Maps a function over the result of a parser

fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>

where G: FnMut(O) -> H, H: Parser<I, O2, E>, Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input

fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>

where G: Parser<O, O2, E>, Self: Sized,

Applies a second parser over the output of the first one

fn and<G, O2>(self, g: G) -> And<Self, G>

where G: Parser<I, O2, E>, Self: Sized,

Applies a second parser after the first one, return their results as a tuple

fn or<G>(self, g: G) -> Or<Self, G>

where G: Parser<I, O, E>, Self: Sized,

Applies a second parser over the input if the first one failed

fn into<O2, E2>(self) -> Into<Self, O, O2, E, E2>

where O2: From<O>, E2: From<E>, Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they implement the From trait

impl PartialEq for ParserError

fn eq(&self, other: &ParserError) -> 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 StructuralPartialEq for ParserError