Struct Reader 

pub struct Reader<'a> { /* private fields */ }

Reader with look-ahead and look-behind methods.

As you read text, the part that you’ve read is accumulated in current_range. The part that you haven’t seen yet is available in tail_range:

valid range: a b c d e f g
               ^^^          - current range
                   ^^^^^^^  - tail range
                 ^          - prev char
                   ^        - current char
                     ^      - next char

Once you call reset_buff, current range is advanced to start at the current char, and shrunk to zero length:

valid range: a b c d e f g
                   .       - current range (empty, starts at `d`)
                   ^^^^^^  - tail range
                 ^         - prev char
                   ^       - current char
                     ^     - next char

The workflow in roughly this:

• you read characters, they’re put into saved_range;
• once you’re at a token boundary, you emit a token with saved_range, then call reset_buff,
• you continue onto the next token.

Implementations

impl<'a> Reader<'a>

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

pub fn new_with_range(text: &'a str, range: SourceRange) -> Self

pub fn bump(&mut self)

pub fn reset_buff(&mut self)

pub fn reset_buff_into_sub_reader(&mut self) -> Reader<'a>

pub fn is_eof(&self) -> bool

pub fn is_start_of_line(&self) -> bool

pub fn prev_char(&self) -> char

pub fn current_char(&self) -> char

pub fn next_char(&mut self) -> char

pub fn current_range(&self) -> SourceRange

pub fn tail_range(&self) -> SourceRange

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

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

pub fn eat_when(&mut self, ch: char) -> usize

pub fn consume_char_n_times(&mut self, ch: char, count: usize) -> usize

pub fn consume_n_times<F>(&mut self, func: F, count: usize) -> usize

where F: Fn(char) -> bool,

pub fn eat_while<F>(&mut self, func: F) -> usize

where F: Fn(char) -> bool,

pub fn eat_till_end(&mut self) -> usize

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

pub fn get_current_end_pos(&self) -> usize

Trait Implementations

impl<'a> Clone for Reader<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Reader<'a>

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

Formats the value using the given formatter.