Enum ParseStatus 

pub enum ParseStatus<'a, P, R> {
    Incomplete {
        new_state: P,
        required_next: Cow<'static, str>,
    },
    Finished {
        result: R,
        remaining: &'a [u8],
    },
}

The state of a parser.

Variants

Incomplete

The parser is incomplete.

Fields

new_state: P

The new state of the parser.

required_next: Cow<'static, str>

The text that is required next.

Finished

The parser is finished.

Fields

result: R

The result of the parser.

remaining: &'a [u8]

The remaining input.

Implementations

impl<'a, P, R> ParseStatus<'a, P, R>

pub fn without_remaining(self) -> ParseStatus<'static, P, R>

Take the remaining bytes from the parser.

pub fn unwrap_finished(self) -> R

Unwrap the parser to a finished result.

pub fn unwrap_incomplete(self) -> (P, Cow<'static, str>)

Unwrap the parser to an incomplete result.

pub fn map<F, O>(self, f: F) -> ParseStatus<'a, P, O>

where F: FnOnce(R) -> O,

Map the result of the parser.

pub fn map_state<F, O>(self, f: F) -> ParseStatus<'a, O, R>

where F: FnOnce(P) -> O,

Map the state of the parser.

Trait Implementations

impl<'a, P: Clone, R: Clone> Clone for ParseStatus<'a, P, R>

fn clone(&self) -> ParseStatus<'a, P, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, P: Debug, R: Debug> Debug for ParseStatus<'a, P, R>

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

Formats the value using the given formatter.

impl<P, R> From<ParseStatus<'_, P, R>> for OwnedParseResult<P, R>

fn from(result: ParseStatus<'_, P, R>) -> Self

Converts to this type from the input type.

impl<'a, P: PartialEq, R: PartialEq> PartialEq for ParseStatus<'a, P, R>

fn eq(&self, other: &ParseStatus<'a, P, R>) -> 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<'a, P: Eq, R: Eq> Eq for ParseStatus<'a, P, R>

impl<'a, P, R> StructuralPartialEq for ParseStatus<'a, P, R>