Struct uwl::Stream

pub struct Stream<'a> { /* fields omitted */ }

A stream of characters. Handles ASCII and/or Unicode.

Methods

impl<'a> Stream<'a>

pub fn new(src: &'a str) -> Self

Create a new stream from a source.

pub fn offset(&self) -> usize

The "offset"; the start of the current char.

Example

use uwl::Stream;

let mut stream = Stream::new("a 🍆");

assert_eq!(stream.offset(), 0);
stream.next();
assert_eq!(stream.offset(), 1);
stream.next();
assert_eq!(stream.offset(), 2);
stream.next();
assert_eq!(stream.offset(), 6);

pub fn source(&self) -> &'a str

Returns the source the stream is operating on.

Example

use uwl::Stream;

let stream = Stream::new("Once upon a time... life");

assert_eq!(stream.source(), "Once upon a time... life");

pub fn len(&self) -> usize

The provided source's length. Returns the amount of bytes.

Example

use uwl::Stream;

let mut stream = Stream::new("abc🍆");
assert_eq!(stream.len(), 7);
stream.next();
// Regardless of any modification method present on the stream,
// `len` always returns a constant.
assert_eq!(stream.len(), 7);

pub fn is_empty(&self) -> bool

Is the provided source empty?

Example

use uwl::Stream;

let stream = Stream::new("");

assert!(stream.is_empty());
assert_eq!(stream.source(), "");

pub fn rest(&self) -> &'a str

Returns the remainder (after the offset).

Example

use uwl::Stream;

let mut stream = Stream::new("foo bar");

assert_eq!(stream.take_until(|s| s == ' '), "foo");
assert_eq!(stream.next(), Some(' '));
assert_eq!(stream.rest(), "bar");

pub fn at_end(&self) -> bool

Determines the end of the input.

Example

use uwl::Stream;

let mut stream = Stream::new("a");

assert!(!stream.at_end());
stream.next();
assert!(stream.at_end());
assert_eq!(stream.current(), None);

pub fn current(&self) -> Option<char>

Fetch the current char.

Example

use uwl::Stream;

let stream = Stream::new("hello");

assert_eq!(stream.current(), Some('h'));

pub fn next(&mut self) -> Option<char>

Advance to the next char

Example

use uwl::Stream;

let mut stream = Stream::new("hello");

assert_eq!(stream.current(), Some('h'));

assert_eq!(stream.next(), Some('h'));
assert_eq!(stream.current(), Some('e'));

pub fn take_while(&mut self, f: impl FnMut(char) -> bool) -> &'a str

Consume while true.

Example

use uwl::Stream;

let mut stream = Stream::new("hello");

assert_eq!(stream.current(), Some('h'));
assert_eq!(stream.take_while(|s| s.is_alphabetic()), "hello");
assert_eq!(stream.current(), None);

pub fn take_until(&mut self, f: impl FnMut(char) -> bool) -> &'a str

Consume until true.

Example

use uwl::Stream;

let mut stream = Stream::new("hello!");

assert_eq!(stream.current(), Some('h'));
assert_eq!(stream.take_until(|s| s == '!'), "hello");
assert_eq!(stream.current(), Some('!'));

pub fn peek_while(&self, f: impl FnMut(char) -> bool) -> &'a str

Lookahead for as long as f returns true. Returns a substring up to the ending character that it landed on.

Example

use uwl::{Stream, CharExt};

let mut stream = Stream::new("hello _wo_r_l_4d");

assert_eq!(stream.peek_while(|s| s.is_alphabetic()), "hello");
assert_eq!(stream.rest(), "hello _wo_r_l_4d");
stream.take_while(|s| s.is_alphabetic());
stream.next();
assert_eq!(stream.peek_while(|s| s.is_diglet()), "_wo_r_l_4d");
assert_eq!(stream.rest(), "_wo_r_l_4d");

pub fn peek_until(&self, f: impl FnMut(char) -> bool) -> &'a str

Lookahead for as long as f does not return true. Returns a substring up to the end it landed on.

Example

use uwl::Stream;

let mut stream = Stream::new("hello!");

assert_eq!(stream.peek_until(|s| s == '!'), "hello");
assert_eq!(stream.rest(), "hello!");

pub fn peek_for(&self, much: usize) -> &'a str

Lookahead by x chars. Returns a substring up to the ending character that it landed on.

Example

use uwl::Stream;

let mut stream = Stream::new("hello world");

assert_eq!(stream.current(), Some('h'));
assert_eq!(stream.peek_for(5), "hello");

for _ in 0..5 {
    stream.next();
}

assert_eq!(stream.next(), Some(' '));
assert_eq!(stream.peek_for(5), "world");
assert_eq!(stream.next(), Some('w'));
assert_eq!(stream.next(), Some('o'));
assert_eq!(stream.next(), Some('r'));
assert_eq!(stream.next(), Some('l'));
assert_eq!(stream.next(), Some('d'));

pub fn advance(&mut self, much: usize) -> &'a str

Advance by x characters. Short-circuits if there are no more characters available.

Example

use uwl::Stream;

let mut stream = Stream::new("hello world");

assert_eq!(stream.advance(5), "hello");
stream.next();
assert_eq!(stream.advance(5), "world");
assert!(stream.at_end());

pub fn eat(&mut self, m: &str) -> bool

Advance if the leading string matches to the expected input. Returns true on succession, false on failure.

Example

use uwl::Stream;

let mut stream = Stream::new("hello world");

assert!(stream.eat("hello"));
assert!(!stream.eat("not a space"));
assert!(stream.eat(" "));
assert_eq!(stream.rest(), "world");

pub fn peek(&self, ahead: usize) -> Option<char>

Lookahead by x characters. Returns the character it landed on.

Example

use uwl::Stream;

let mut stream = Stream::new("hello");

assert_eq!(stream.current(), Some('h'));
assert_eq!(stream.peek(1), Some('e'));
assert_eq!(stream.current(), Some('h'));
assert_eq!(stream.peek(2), Some('l'));
assert_eq!(stream.current(), Some('h'));

pub fn set(&mut self, pos: usize)

Set the offset to the pos.

pub fn increment(&mut self, n: usize)

Increment the offset by n bytes.

Trait Implementations

impl<'a> Debug for Stream<'a>

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

Formats the value using the given formatter.

impl<'a> Copy for Stream<'a>

impl<'a> Clone for Stream<'a>

fn clone(&self) -> Stream<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Default for Stream<'a>

fn default() -> Stream<'a>

Returns the "default value" for a type.