Struct combine::stream::buffered::Stream

pub struct Stream<Input>
where
    Input: 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 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(..));

Implementations

impl<Input> Stream<Input>

where Input: StreamOnce + Positioned, Input::Position: Clone, Input::Token: Clone,

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

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

Trait Implementations

impl<Input> Debug for Stream<Input>

where Input: StreamOnce + Positioned + Debug, Input::Token: Debug, Input::Position: Debug,

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

Formats the value using the given formatter.

impl<Input> PartialEq for Stream<Input>

where Input: StreamOnce + Positioned + PartialEq, Input::Token: PartialEq, Input::Position: PartialEq,

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Input> Positioned for Stream<Input>

where Input: StreamOnce + Positioned,

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

Returns the current position of the stream.

impl<Input> ResetStream for Stream<Input>

where Input: 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<Input> StreamOnce for Stream<Input>

where Input: StreamOnce + Positioned, Input::Token: Clone,

type Token = <Input as StreamOnce>::Token

The type of items which is yielded from this stream.

type Range = <Input 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::Token for this type.

type Position = <Input 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 = <Input as StreamOnce>::Error

fn uncons(&mut self) -> Result<Input::Token, StreamErrorFor<Self>>

Takes a stream and removes its first token, yielding the token 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<Input> StructuralPartialEq for Stream<Input>

where Input: StreamOnce + Positioned,