Struct combine::stream::easy::Errors

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

This is supported on crate feature std only.

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

Fields

position: P

The position where the error occurred

errors: Vec<Error<T, 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.

Implementations

impl<T, R, P> Errors<T, R, P>

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

Constructs a new ParseError which occurred at position.

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

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

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

Constructs a ParseError with multiple causes.

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

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

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

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

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

Removes all Expected errors in self and adds info instead.

pub fn merge(self, other: Errors<T, R, P>) -> Errors<T, R, P> where
    P: Ord,
    T: 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.

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

Maps the position to a new value

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

Maps all token variants to a new value

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

Maps all range variants to a new value.

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

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<T, R, P> Error for Errors<T, R, P> where
    P: Display + Debug,
    T: Display + Debug,
    R: Display + Debug, 

pub fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

pub fn source(&self) -> Option<&(dyn Error + 'static)>

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

pub fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

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

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl<'a, P> From<Error<Errors<u8, &'a [u8], P>, P>> for Errors<u8, &'a [u8], P> where
    P: Ord + Clone, 

pub fn from(e: Error<Errors<u8, &'a [u8], P>, P>) -> Self

Performs the conversion.

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

type StreamError = Error<Item, Range>

pub fn empty(pos: Position) -> Self

Constructs an empty error.

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

Creates a ParseError from a single Self::StreamError

pub fn position(&self) -> Position

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

Sets the position of this ParseError

pub 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.

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

Adds a StreamError to self.

pub 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

pub fn clear_expected(&mut self)

Removes any expected errors currently in self

pub fn is_unexpected_end_of_input(&self) -> bool

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

Does a best-effort conversion of self into another ParseError

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

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

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

impl<Item, Range, Position> ParseErrorInto<Item, Range, Position> for Errors<Item, Range, Position>

pub fn into_other_error<T, Item2, Range2, Position2>(self) -> T where
    T: ParseError<Item2, Range2, Position2>,
    Item2: From<Item>,
    Range2: From<Range>,
    Position2: From<Position>, 

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

pub fn eq(&self, other: &Errors<T, R, P>) -> bool

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

pub fn ne(&self, other: &Errors<T, R, P>) -> bool

This method tests for !=.

impl<T, R, P> StructuralPartialEq for Errors<T, R, P>