Struct combine::stream::easy::Errors

pub struct Errors<I, R, P> {
    pub position: P,
    pub errors: Vec<Error<I, R>>,
}

Struct which hold information about an error that occured at a specific position. Can hold multiple instances of Error if more that one error occured in the same position.

Fields

position: P

The position where the error occurred

errors: Vec<Error<I, R>>

A vector containing specific information on what errors occurred at position. Usually a fully formed message contains one Unexpected error and one or more Expected errors. Message and Other may also appear (combine never generates these errors on its own) and may warrant custom handling.

Methods

impl<I, R, P> Errors<I, R, P>

fn new(position: P, error: Error<I, R>) -> Errors<I, R, P>

Constructs a new ParseError which occurred at position.

fn empty(position: P) -> Errors<I, R, P>

Constructs an error with no other information than the position it occurred at.

fn from_errors(position: P, errors: Vec<Error<I, R>>) -> Errors<I, R, P>

Constructs a ParseError with multiple causes.

fn end_of_input(position: P) -> Errors<I, R, P>

Constructs an end of input error. Should be returned by parsers which encounter end of input unexpectedly.

fn add_error(&mut self, error: Error<I, R>) where
    I: PartialEq,
    R: PartialEq, 

Adds an error if error does not exist in this ParseError already (as determined byte PartialEq).

fn set_expected(&mut self, info: Info<I, R>)

Remvoes all Expected errors in self and adds info instead.

fn merge(self, other: Errors<I, R, P>) -> Errors<I, R, P> where
    P: Ord,
    I: PartialEq,
    R: PartialEq, 

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

fn map_position<F, Q>(self, f: F) -> Errors<I, R, Q> where
    F: FnOnce(P) -> Q, 

Maps the position to a new value

fn map_token<F, U>(self, f: F) -> Errors<U, R, P> where
    F: FnMut(I) -> U, 

Maps all token variants to a new value

fn map_range<F, S>(self, f: F) -> Errors<I, S, P> where
    F: FnMut(R) -> S, 

Maps all range variants to a new value.

use combine::Parser;
use combine::parser::range::range;
println!(
    "{}",
    range(&"HTTP"[..])
        .easy_parse("HTT")
        .unwrap_err()
        .map_range(|bytes| format!("{:?}", bytes))
);

Trait Implementations

impl<Item, Range, Position> ParseError<Item, Range, Position> for Errors<Item, Range, Position> where
    Item: PartialEq,
    Range: PartialEq,
    Position: Ord, 

type StreamError = Error<Item, Range>

fn empty(pos: Position) -> Self

Constructs an empty error.

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

Creates a ParseError from a single Self::StreamError

fn set_position(&mut self, position: Position)

Sets the position of this ParseError

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

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.

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

Adds a StreamError to self.

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

Sets info as the only Expected error of self

fn is_unexpected_end_of_input(&self) -> bool

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

Does a best-effort conversion of self into another ParseError

fn add_expected(&mut self, info: Info<Item, Range>)

fn add_unexpected(&mut self, info: Info<Item, Range>)

fn add_message(&mut self, info: Info<Item, Range>)

impl<I: Debug, R: Debug, P: Debug> Debug for Errors<I, R, P>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<I: PartialEq, R: PartialEq, P: PartialEq> PartialEq for Errors<I, R, P>

fn eq(&self, __arg_0: &Errors<I, R, P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Errors<I, R, P>) -> bool

This method tests for !=.

impl<I, R, P> StdError for Errors<I, R, P> where
    P: Display + Debug + Any,
    I: Display + Debug + Any,
    R: Display + Debug + Any, 

fn description(&self) -> &str

A short description of the error.

fn cause(&self) -> Option<&Error>

The lower-level cause of this error, if any.

impl<I, R, P> Display for Errors<I, R, P> where
    P: Display,
    I: Display,
    R: Display, 

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

Formats the value using the given formatter.