Struct combine::stream::position::Stream

pub struct Stream<Input, X> {
    pub input: Input,
    pub positioner: X,
}

The Stream<Input> struct maintains the current position in the stream Input using the Positioner trait to track the position.

    let result = token(b'9')
        .message("Not a nine")
        .easy_parse(position::Stream::new(&b"8"[..]));
    assert_eq!(result, Err(easy::Errors {
        position: 0,
        errors: vec![
            easy::Error::Unexpected(b'8'.into()),
            easy::Error::Expected(b'9'.into()),
            easy::Error::Message("Not a nine".into())
        ]
    }));

Fields

input: Input

The input stream used when items are requested

positioner: X

The positioner used to update the current position

Implementations

impl<Input, X> Stream<Input, X> where
    Input: StreamOnce,
    X: Positioner<Input::Token>, 

pub fn with_positioner(input: Input, positioner: X) -> Stream<Input, X>

Creates a new Stream<Input, X> from an input stream and a positioner.

impl<Input> Stream<Input, Input::Positioner> where
    Input: StreamOnce + DefaultPositioned,
    Input::Positioner: Positioner<Input::Token>, 

pub fn new(input: Input) -> Stream<Input, Input::Positioner>

Creates a new Stream<Input, X> from an input stream and its default positioner.

Trait Implementations

impl<Input: Clone, X: Clone> Clone for Stream<Input, X>

fn clone(&self) -> Stream<Input, X>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Input: Debug, X: Debug> Debug for Stream<Input, X>

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

Formats the value using the given formatter.

impl<Input: PartialEq, X: PartialEq> PartialEq<Stream<Input, X>> for Stream<Input, X>

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

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

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

This method tests for !=.

impl<Input, X, E> Positioned for Stream<Input, X> where
    Input: StreamOnce,
    X: Positioner<Input::Token>,
    E: StreamError<Input::Token, Input::Range>,
    Input::Error: ParseError<Input::Token, Input::Range, X::Position, StreamError = E>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position, StreamError = E>, 

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

Returns the current position of the stream.

impl<Input, X, S> RangeStreamOnce for Stream<Input, X> where
    Input: RangeStreamOnce,
    X: RangePositioner<Input::Token, Input::Range>,
    S: StreamError<Input::Token, Input::Range>,
    Input::Error: ParseError<Input::Token, Input::Range, X::Position, StreamError = S>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position, StreamError = S>,
    Input::Position: Clone + Ord, 

fn uncons_range(
    &mut self,
    size: usize
) -> Result<Input::Range, StreamErrorFor<Self>>

Takes size elements from the stream. Fails if the length of the stream is less than size.

fn uncons_while<F>(
    &mut self,
    predicate: F
) -> Result<Input::Range, StreamErrorFor<Self>> where
    F: FnMut(Input::Token) -> bool, 

Takes items from stream, testing each one with predicate. returns the range of items which passed predicate.

fn uncons_while1<F>(
    &mut self,
    predicate: F
) -> ParseResult<Self::Range, StreamErrorFor<Self>> where
    F: FnMut(Self::Token) -> bool, 

Takes items from stream, testing each one with predicate returns a range of at least one items which passed predicate.

fn distance(&self, end: &Self::Checkpoint) -> usize

Returns the distance between self and end. The returned usize must be so that

fn range(&self) -> Self::Range

Returns the entire range of self

impl<Input, X, S> ResetStream for Stream<Input, X> where
    Input: ResetStream,
    X: Positioner<Input::Token>,
    S: StreamError<Input::Token, Input::Range>,
    Input::Error: ParseError<Input::Token, Input::Range, X::Position, StreamError = S>,
    Input::Error: ParseError<Input::Token, Input::Range, Input::Position, StreamError = S>, 

type Checkpoint = Stream<<Input as ResetStream>::Checkpoint, <X as Positioner<<Input as StreamOnce>::Token>>::Checkpoint>

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, X, S> StreamOnce for Stream<Input, X> where
    Input: StreamOnce,
    X: Positioner<Input::Token>,
    S: StreamError<Input::Token, Input::Range>,
    Input::Error: ParseError<Input::Token, Input::Range, X::Position, StreamError = S> + ParseError<Input::Token, Input::Range, Input::Position, StreamError = S>, 

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 = <X as Positioner<<Input as StreamOnce>::Token>>::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, X> StructuralPartialEq for Stream<Input, X>