Struct generic_lexer::BufferedInput

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

Methods

impl<'a> BufferedInput<'a>

pub fn take_buffer(&mut self) -> String

Copy out the buffer and clear it

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

Peek at the next character

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

Get the next character but don't push it to the buffer

pub fn skip_if<P: Fn(&char) -> bool>(&mut self, predicate: P) -> Option<char>

Skip if the given predicate is true

pub fn skip_while<P: Fn(&char) -> bool>(&mut self, predicate: P)

Skip while the given predicate is true

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

Retrieve the next character and increment the input position

pub fn accept_if<P: Fn(&char) -> bool>(&mut self, predicate: P) -> Option<char>

Call self.next() if the peeked character is identical to b

pub fn accept_while<P: Fn(&char) -> bool>(&mut self, predicate: P)

Call self.next() while the peeked character fulfils predicate

pub fn accept_or<P: Fn(&char) -> bool, T>(
    &mut self,
    predicate: P,
    ok: T,
    default: T
) -> T

Accept the given byte and return ok, or else return default

This is useful for matching multi-character tokens:

match c {
    '=' => input.accept_or(|&c| c == '=', TokenKind::DoubleEquals, TokenKind::Equals),
    _ => {},
}

pub fn skip_whitespace(&mut self)

Skip whitespace, preserving the original buffer before any whitespace was encountered