Struct Recoverable

pub struct Recoverable<I, E>
where
    I: Stream,
{ /* private fields */ }

Available on crate features unstable-recover and std only.

Allow recovering from parse errors, capturing them as the parser continues

Generally, this will be used indirectly via RecoverableParser::recoverable_parse.

Implementations

impl<I, E> Recoverable<I, E>

where I: Stream,

pub fn new(input: I) -> Self

Track recoverable errors with the stream

pub fn unrecoverable(input: I) -> Self

Act as a normal stream

pub fn into_parts(self) -> (I, Vec<E>)

Access the current input and errors

Trait Implementations

impl<I, E> AsBStr for Recoverable<I, E>

where I: Stream + AsBStr,

fn as_bstr(&self) -> &[u8]

Casts the input type to a byte slice

impl<I, E> AsBytes for Recoverable<I, E>

where I: Stream + AsBytes,

fn as_bytes(&self) -> &[u8]

Casts the input type to a byte slice

impl<I, E> AsRef<I> for Recoverable<I, E>

where I: Stream,

fn as_ref(&self) -> &I

Converts this type into a shared reference of the (usually inferred) input type.

impl<I, E: Clone> Clone for Recoverable<I, E>

where I: Stream + Clone,

fn clone(&self) -> Recoverable<I, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, E, U> Compare<U> for Recoverable<I, E>

where I: Stream + Compare<U>,

fn compare(&self, other: U) -> CompareResult

Compares self to another value for equality

impl<I, E: Debug> Debug for Recoverable<I, E>

where I: Stream + Debug,

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

Formats the value using the given formatter.

impl<I, E> Default for Recoverable<I, E>

where I: Default + Stream,

fn default() -> Self

Returns the “default value” for a type.

impl<I, E> Deref for Recoverable<I, E>

where I: Stream,

type Target = I

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<I, E> Display for Recoverable<I, E>

where I: Stream + Display,

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

Formats the value using the given formatter.

impl<I, E, T> FindSlice<T> for Recoverable<I, E>

where I: Stream + FindSlice<T>,

fn find_slice(&self, substr: T) -> Option<Range<usize>>

Returns the offset of the slice if it is found

impl<I, E> Location for Recoverable<I, E>

where I: Location + Stream,

fn previous_token_end(&self) -> usize

Previous token’s end offset

fn current_token_start(&self) -> usize

Current token’s start offset

impl<I, E> Offset<<Recoverable<I, E> as Stream>::Checkpoint> for Recoverable<I, E>

where I: Stream, E: Debug,

fn offset_from( &self, other: &<Recoverable<I, E> as Stream>::Checkpoint, ) -> usize

Offset between the first byte of start and the first byte of selfa

impl<I, E> Offset for Recoverable<I, E>

where I: Stream, E: Debug,

fn offset_from(&self, other: &Self) -> usize

Offset between the first byte of start and the first byte of selfa

impl<I, E, R> Recover<E> for Recoverable<I, R>

where I: Stream, R: FromRecoverableError<Self, E> + Debug, E: ParserError<Self>,

fn is_recovery_supported() -> bool

Report whether the Stream can save off errors for recovery

fn record_err( &mut self, token_start: &Self::Checkpoint, err_start: &Self::Checkpoint, err: E, ) -> Result<(), E>

Capture a top-level error

impl<I, E> SliceLen for Recoverable<I, E>

where I: SliceLen + Stream,

fn slice_len(&self) -> usize

Calculates the input length, as indicated by its name, and the name of the trait itself

impl<I, E: Debug> Stream for Recoverable<I, E>

where I: Stream,

type Token = <I as Stream>::Token

The smallest unit being parsed

type Slice = <I as Stream>::Slice

Sequence of Tokens

type IterOffsets = <I as Stream>::IterOffsets

Iterate with the offset from the current location

type Checkpoint = Checkpoint<<I as Stream>::Checkpoint, Recoverable<I, E>>

A parse location within the stream

fn iter_offsets(&self) -> Self::IterOffsets

Iterate with the offset from the current location

fn eof_offset(&self) -> usize

Returns the offset to the end of the input

fn next_token(&mut self) -> Option<Self::Token>

Split off the next token from the input

fn peek_token(&self) -> Option<Self::Token>

Split off the next token from the input

fn offset_for<P>(&self, predicate: P) -> Option<usize>

where P: Fn(Self::Token) -> bool,

Finds the offset of the next matching token

fn offset_at(&self, tokens: usize) -> Result<usize, Needed>

Get the offset for the number of tokens into the stream

fn next_slice(&mut self, offset: usize) -> Self::Slice

Split off a slice of tokens from the input

unsafe fn next_slice_unchecked(&mut self, offset: usize) -> Self::Slice

Split off a slice of tokens from the input

fn peek_slice(&self, offset: usize) -> Self::Slice

Split off a slice of tokens from the input

unsafe fn peek_slice_unchecked(&self, offset: usize) -> Self::Slice

Split off a slice of tokens from the input

fn checkpoint(&self) -> Self::Checkpoint

Save the current parse location within the stream

fn reset(&mut self, checkpoint: &Self::Checkpoint)

Revert the stream to a prior Self::Checkpoint

fn raw(&self) -> &dyn Debug

👎Deprecated since 0.7.10: Replaced with Stream::trace

Deprecated for callers as of 0.7.10, instead call Stream::trace

fn finish(&mut self) -> Self::Slice

Advance to the end of the stream

fn peek_finish(&self) -> Self::Slice

where Self: Clone,

Advance to the end of the stream

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

Write out a single-line summary of the current parse location

impl<I, E> StreamIsPartial for Recoverable<I, E>

where I: StreamIsPartial + Stream,

type PartialState = <I as StreamIsPartial>::PartialState

Whether the stream is currently partial or complete

fn complete(&mut self) -> Self::PartialState

Mark the stream is complete

fn restore_partial(&mut self, state: Self::PartialState)

Restore the stream back to its previous state

fn is_partial_supported() -> bool

Report whether the Stream is can ever be incomplete

fn is_partial(&self) -> bool

Report whether the Stream is currently incomplete

impl<I, E> UpdateSlice for Recoverable<I, E>

where I: Stream + UpdateSlice, E: Debug,

fn update_slice(self, inner: Self::Slice) -> Self

Convert an Output type to be used as Stream