Struct combine::ParseError

pub struct ParseError<S: StreamOnce> {
    pub position: S::Position,
    pub errors: Vec<Error<S::Item, S::Range>>,
}

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: S::Position

The position where the error occured

errors: Vec<Error<S::Item, S::Range>>

A vector containing specific information on what errors occured at position

Methods

impl<S: StreamOnce> ParseError<S>

fn new(position: S::Position, error: Error<S::Item, S::Range>) -> ParseError<S>

fn empty(position: S::Position) -> ParseError<S>

fn from_errors(position: S::Position,
               errors: Vec<Error<S::Item, S::Range>>)
               -> ParseError<S>

fn end_of_input(position: S::Position) -> ParseError<S>

fn add_message<M>(&mut self, message: M) where M: Into<Info<S::Item, S::Range>>

fn add_error(&mut self, message: Error<S::Item, S::Range>)

fn set_expected(&mut self, message: Info<S::Item, S::Range>)

fn merge(self, other: ParseError<S>) -> ParseError<S>

impl<'s> ParseError<&'s str>

fn translate_position(self, initial_string: &'s str) -> ParseError<&'s str>

Converts the pointer-based position into an indexed position

let text = "b";
let err = token('a').parse(text).unwrap_err();
assert_eq!(err.position, text.as_ptr() as usize);
assert_eq!(err.translate_position(text).position, 0);

impl<'s, T: 's> ParseError<&'s [T]> where T: Clone + PartialEq

fn translate_position(self, initial_string: &'s [T]) -> ParseError<&'s [T]>

Converts the pointer-based position into an indexed position

let text = b"b";
let err = token(b'a').parse(&text[..]).unwrap_err();
assert_eq!(err.position, text.as_ptr() as usize);
assert_eq!(err.translate_position(text).position, 0);

Trait Implementations

impl<S> StdError for ParseError<S> where S: Stream,
        S::Range: Display + Debug + Any,
        S::Item: Display + Debug + Any,
        S::Position: 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<S> PartialEq for ParseError<S> where S: Stream, S::Position: PartialEq

fn eq(&self, other: &ParseError<S>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<S> Debug for ParseError<S> where S: Stream,
        S::Range: Debug,
        S::Item: Debug,
        S::Position: Debug

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

Formats the value using the given formatter.

impl<S> Display for ParseError<S> where S: Stream,
        S::Item: Display,
        S::Range: Display,
        S::Position: Display

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

Formats the value using the given formatter.