Enum OwnedParseResult

pub enum OwnedParseResult<P, R> {
    Incomplete {
        new_state: P,
        required_next: Cow<'static, str>,
    },
    Finished {
        result: R,
        remaining: Vec<u8>,
    },
}

A parser for a choice between two parsers.

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: Vec<u8>

The remaining input.

Trait Implementations

impl<P: Clone, R: Clone> Clone for OwnedParseResult<P, R>

fn clone(&self) -> OwnedParseResult<P, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug, R: Debug> Debug for OwnedParseResult<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<P: PartialEq, R: PartialEq> PartialEq for OwnedParseResult<P, R>

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

impl<P, R> StructuralPartialEq for OwnedParseResult<P, R>