Struct BufferedStream

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

Stream which buffers items from an instance of StreamOnce into a ring buffer. Instances of StreamOnce which is not able to implement Resetable (such as ReadStream) may use this as a way to implement Resetable 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 BufferedStream 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 BufferedStream instance wraps the easy::Stream instance instead of the other way around.

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

Implementations

impl<I> BufferedStream<I>

where I: StreamOnce + Positioned, I::Position: Clone, I::Item: Clone,

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

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

Trait Implementations

impl<I> Debug for BufferedStream<I>

where I: StreamOnce + Positioned + Debug, I::Item: Debug, I::Position: Debug,

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

Formats the value using the given formatter.

impl<I> PartialEq for BufferedStream<I>

where I: StreamOnce + Positioned + PartialEq, I::Item: PartialEq, I::Position: PartialEq,

fn eq(&self, other: &BufferedStream<I>) -> 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<I> Positioned for BufferedStream<I>

where I: StreamOnce + Positioned,

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

Returns the current position of the stream.

impl<I> Resetable for BufferedStream<I>

where I: Positioned,

type Checkpoint = usize

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

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

impl<I> StreamOnce for BufferedStream<I>

where I: StreamOnce + Positioned, I::Item: Clone + PartialEq,

type Item = <I as StreamOnce>::Item

The type of items which is yielded from this stream.

type Range = <I as StreamOnce>::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 as StreamOnce>::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 as StreamOnce>::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> StructuralPartialEq for BufferedStream<I>

where I: StreamOnce + Positioned,