Trait winnow::stream::Stream

pub trait Stream: Offset<Self::Checkpoint> + Debug {
    type Token: Debug;
    type Slice: Debug;
    type IterOffsets: Iterator<Item = (usize, Self::Token)>;
    type Checkpoint: Offset + Clone + Debug;

    // Required methods
    fn iter_offsets(&self) -> Self::IterOffsets;
    fn eof_offset(&self) -> usize;
    fn next_token(&mut self) -> Option<Self::Token>;
    fn offset_for<P>(&self, predicate: P) -> Option<usize>
       where P: Fn(Self::Token) -> bool;
    fn offset_at(&self, tokens: usize) -> Result<usize, Needed>;
    fn next_slice(&mut self, offset: usize) -> Self::Slice;
    fn checkpoint(&self) -> Self::Checkpoint;
    fn reset(&mut self, checkpoint: &Self::Checkpoint);
    fn raw(&self) -> &dyn Debug;

    // Provided methods
    fn peek_token(&self) -> Option<(Self, Self::Token)>
       where Self: Clone { ... }
    fn peek_slice(&self, offset: usize) -> (Self, Self::Slice)
       where Self: Clone { ... }
    fn finish(&mut self) -> Self::Slice { ... }
    fn peek_finish(&self) -> (Self, Self::Slice)
       where Self: Clone { ... }
}

Core definition for parser input state

Required Associated Types

type Token: Debug

The smallest unit being parsed

Example: u8 for &[u8] or char for &str

type Slice: Debug

Sequence of Tokens

Example: &[u8] for Located<&[u8]> or &str for Located<&str>

type IterOffsets: Iterator<Item = (usize, Self::Token)>

Iterate with the offset from the current location

type Checkpoint: Offset + Clone + Debug

A parse location within the stream

Required Methods

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

This means “0 tokens” will return 0 offset

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

Split off a slice of tokens from the input

NOTE: For inputs with variable width tokens, like &str’s char, offset might not correspond with the number of tokens. To get a valid offset, use:

• Stream::eof_offset
• Stream::iter_offsets
• Stream::offset_for
• Stream::offset_at

Panic

This will panic if

• Indexes must be within bounds of the original input;
• Indexes must uphold invariants of the stream, like for str they must lie on UTF-8 sequence boundaries.

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

Panic

May panic if an invalid Self::Checkpoint is provided

fn raw(&self) -> &dyn Debug

Return the inner-most stream

Provided Methods

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

where Self: Clone,

Split off the next token from the input

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

where Self: Clone,

Split off a slice of tokens from the input

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

Advance to the end of the stream

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

where Self: Clone,

Advance to the end of the stream

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'i> Stream for &'i str

type Token = char

type Slice = &'i str

type IterOffsets = CharIndices<'i>

type Checkpoint = Checkpoint<&'i str, &'i str>

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

fn eof_offset(&self) -> usize

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

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

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

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

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

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

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

fn raw(&self) -> &dyn Debug

impl<'i, T> Stream for &'i [T]

where T: Clone + Debug,

type Token = T

type Slice = &'i [T]

type IterOffsets = Enumerate<Cloned<Iter<'i, T>>>

type Checkpoint = Checkpoint<&'i [T], &'i [T]>

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

fn eof_offset(&self) -> usize

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

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

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

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

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

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

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

fn raw(&self) -> &dyn Debug

impl<I> Stream for (I, usize)

where I: Stream<Token = u8> + Clone,

type Token = bool

type Slice = (<I as Stream>::Slice, usize, usize)

type IterOffsets = BitOffsets<I>

type Checkpoint = Checkpoint<(<I as Stream>::Checkpoint, usize), (I, usize)>

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

fn eof_offset(&self) -> usize

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

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

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

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

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

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

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

fn raw(&self) -> &dyn Debug

Implementors

impl<'i> Stream for &'i BStr

type Token = u8

type Slice = &'i [u8]

type IterOffsets = Enumerate<Cloned<Iter<'i, u8>>>

type Checkpoint = Checkpoint<&'i BStr, &'i BStr>

impl<'i> Stream for &'i Bytes

type Token = u8

type Slice = &'i [u8]

type IterOffsets = Enumerate<Cloned<Iter<'i, u8>>>

type Checkpoint = Checkpoint<&'i Bytes, &'i Bytes>

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

where I: Stream,

Available on crate feature unstable-recover only.

type Token = <I as Stream>::Token

type Slice = <I as Stream>::Slice

type IterOffsets = <I as Stream>::IterOffsets

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

impl<I: Stream> Stream for Located<I>

type Token = <I as Stream>::Token

type Slice = <I as Stream>::Slice

type IterOffsets = <I as Stream>::IterOffsets

type Checkpoint = Checkpoint<<I as Stream>::Checkpoint, Located<I>>

impl<I: Stream> Stream for Partial<I>

type Token = <I as Stream>::Token

type Slice = <I as Stream>::Slice

type IterOffsets = <I as Stream>::IterOffsets

type Checkpoint = Checkpoint<<I as Stream>::Checkpoint, Partial<I>>

impl<I: Stream, S: Debug> Stream for Stateful<I, S>

type Token = <I as Stream>::Token

type Slice = <I as Stream>::Slice

type IterOffsets = <I as Stream>::IterOffsets

type Checkpoint = Checkpoint<<I as Stream>::Checkpoint, Stateful<I, S>>