Trait combine::ParseError[−][src]

pub trait ParseError<Item, Range, Position>: Sized + PartialEq {
    type StreamError: StreamError<Item, Range>;

Show 13 methods    fn empty(position: Position) -> Self;

    fn set_position(&mut self, position: Position);

    fn add(&mut self, err: Self::StreamError);

    fn set_expected<F>(self_: &mut Tracked<Self>, info: Self::StreamError, f: F)
    where
        F: FnOnce(&mut Tracked<Self>);

    fn is_unexpected_end_of_input(&self) -> bool;

    fn into_other<T>(self) -> T
    where
        T: ParseError<Item, Range, Position>;

    fn from_error(position: Position, err: Self::StreamError) -> Self { ... }

    fn position(&self) -> Position { ... }

    fn merge(self, other: Self) -> Self { ... }

    fn add_expected<E>(&mut self, info: E)
    where
        E: for<'s> ErrorInfo<'s, Item, Range>,
    { ... }

    fn add_unexpected<E>(&mut self, info: E)
    where
        E: for<'s> ErrorInfo<'s, Item, Range>,
    { ... }

    fn add_message<E>(&mut self, info: E)
    where
        E: for<'s> ErrorInfo<'s, Item, Range>,
    { ... }

    fn clear_expected(&mut self) { ... }

}
Expand description

Trait which defines a combine parse error.

A parse error is composed of zero or more StreamError instances which gets added to it as errors are encountered during parsing.

Associated Types

Required methods

Constructs an empty error.

An empty error is expected to be cheap to create as it is frequently created and discarded.

Sets the position of this ParseError

Adds a StreamError to self.

It is up to each individual error type to define what adding an error does, some may push it to a vector while others may only keep self or err to avoid allocation

Sets info as the only Expected error of self

Does a best-effort conversion of self into another ParseError

Provided methods

Creates a ParseError from a single Self::StreamError

Merges two errors. If they exist at the same position the errors of other are added to self (using the semantics of add). If they are not at the same position the error furthest ahead are returned, ignoring the other ParseError.

Removes any expected errors currently in self

Implementors