Struct combine::stream::buffered::Stream

pub struct Stream<I> where
    I: StreamOnce + Positioned,  { /* fields omitted */ }

Stream which buffers items from an instance of StreamOnce into a ring buffer. Instances of StreamOnce which is not able to implement ResetStream (such as ReadStream) may use this as a way to implement ResetStream and become a full Stream instance.

The drawback is that the buffer only stores a limited number of items which limits how many tokens that can be reset and replayed. If a buffered::Stream is reset past this limit an error will be returned when uncons is next called.

NOTE: If this stream is used in conjunction with an error enhancing stream such as easy::Stream (also via the easy_parser method) it is recommended that the buffered::Stream instance wraps the easy::Stream instance instead of the other way around.

// DO
buffered::Stream::new(easy::Stream(..), ..)
// DON'T
easy::Stream(buffered::Stream::new(.., ..))
parser.easy_parse(buffered::Stream::new(..));

Methods

impl<I> Stream<I> where
    I: StreamOnce + Positioned,
    I::Position: Clone,
    I::Item: Clone, 

pub fn new(iter: I, lookahead: usize) -> Stream<I>

Constructs a new Stream from a StreamOnce instance with a lookahead number of elements that can be stored in the buffer.

Trait Implementations

impl<I> Positioned for Stream<I> where
    I: StreamOnce + Positioned, 

fn position(&self) -> Self::Position

Returns the current position of the stream.

impl<I> StreamOnce for Stream<I> where
    I: StreamOnce + Positioned, 

type Item = I::Item

The type of items which is yielded from this stream.

type Range = I::Range

The type of a range of items yielded from this stream. Types which do not a have a way of yielding ranges of items should just use the Self::Item for this type.

type Position = I::Position

Type which represents the position in a stream. Ord is required to allow parsers to determine which of two positions are further ahead.

type Error = I::Error

fn uncons(&mut self) -> Result<I::Item, StreamErrorFor<Self>>

Takes a stream and removes its first item, yielding the item and the rest of the elements. Returns Err if no element could be retrieved.

fn is_partial(&self) -> bool

Returns true if this stream only contains partial input.

impl<I> ResetStream for Stream<I> where
    I: Positioned, 

type Checkpoint = usize

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

Creates a Checkpoint at the current position which can be used to reset the stream later to the current position

fn reset(&mut self, checkpoint: Self::Checkpoint) -> Result<(), Self::Error>

Attempts to reset the stream to an earlier position.

impl<I: PartialEq> PartialEq<Stream<I>> for Stream<I> where
    I: StreamOnce + Positioned,
    I::Item: PartialEq,
    I::Position: PartialEq, 

fn eq(&self, other: &Stream<I>) -> bool

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

fn ne(&self, other: &Stream<I>) -> bool

This method tests for !=.

impl<I: Debug> Debug for Stream<I> where
    I: StreamOnce + Positioned,
    I::Item: Debug,
    I::Position: Debug, 

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

Formats the value using the given formatter.