Struct ress::JSBuffer

pub struct JSBuffer<'a> {
    pub buffer: &'a [u8],
    pub idx: usize,
    pub len: usize,
}

Fields

buffer: &'a [u8]

idx: usize

len: usize

Implementations

impl<'a> JSBuffer<'a>

Re-implementation of the std::str::Chars logic

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

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

impl<'a> JSBuffer<'a>

pub fn new(buffer: &'a [u8]) -> Self

pub fn at_end(&self) -> bool

Check if the buffer is at or past the end of the bytes provided

pub fn look_ahead_matches(&self, s: &[u8]) -> bool

Check if the next few bytes match the provided bytes

pub fn look_ahead_byte_matches(&self, b: u8) -> bool

Check if the next byte matches a single byte provided

pub fn skip(&mut self, count: usize)

Skip the number of characters provided returning the number of bytes skipped note: these are full unicode characters, not just bytes

pub fn skip_back(&mut self, count: usize)

pub fn skip_bytes(&mut self, count: usize)

Skip a single byte note: this can cause the buffer to become unaligned be sure to always know the character you are skipping is 1 byte wide or use skip instead when unsure

pub fn at_whitespace(&mut self) -> bool

check if current char is a valid js whitespace character

pub fn at_new_line(&mut self) -> bool

Check of the look ahead character is a valid js new line character

pub fn at_binary(&self) -> bool

check if the look ahead character is 0 or 1

pub fn at_decimal(&self) -> bool

check if the look ahead character is a number between 0 and 9, inclusive

pub fn at_octal(&self) -> bool

check if the look ahead character is a number between 0 and 7, inclusive

pub fn at_hex(&self) -> bool

check if the look ahead character is a number between 0 and 9 or a and f or A and F, inclusive

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

Peek forward 1 char with out updating the idx to this new position.

note: this will still cost the same amount of work as next_char but cleans up the book keeping for you

pub fn skip_back_bytes(&mut self, count: usize)

Skip backwards a number of bytes note: this can cause the buffer to become unaligned be sure to always know the character you are skipping is [count] bytes wide or use skip instead when unsure the right width is skipped

Trait Implementations

impl<'a> Clone for JSBuffer<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> From<&'a str> for JSBuffer<'a>

fn from(s: &'a str) -> JSBuffer<'_>

Converts to this type from the input type.