Struct byte_reader::Reader

pub struct Reader<B: Bytes> { /* private fields */ }

Implementations

impl<B: Bytes> Reader<B>

pub fn new(content: B) -> Self

Generate new Reader from &str | String | &[u8] | Vec<u8>

Examples found in repository

examples/usage.rs (line 9)

fn main() {
    // Get a input from a File, standard input, or others
    // Input can be `&str`, `String`, `&[u8]`, or `Vec<u8>`
    let sample_input = "Hello,    byte_reader!";

    // Create mutable `r`
    let mut r = Reader::new(sample_input);

    // Use some simple operations
    // to parse the input
    r.consume("Hello").unwrap();
    r.consume(",").unwrap();
    r.skip_whitespace();
    let name = r.read_snake().unwrap(); // byte_reader
    r.consume("!").unwrap();

    println!("Greeted to `{name}`.");
}

impl<B: Bytes> Reader<B>

pub fn advance_by(&mut self, max: usize)

Advance by max bytes (or, if remained bytes is shorter than max, read all remained bytes)

pub fn unwind_by(&mut self, max: usize)

Unwind the parsing point by max bytes (or, if already-read bytes is shorter than max, rewind all)

When "location" feature is activated, this may be less performant for some extensive input

pub fn skip_while(&mut self, condition: impl Fn(&u8) -> bool)

Skip next byte while condition holds on it

pub fn skip_whitespace(&mut self)

.skip_while(|b| b.is_ascii_whitespace())

Examples found in repository

examples/usage.rs (line 15)

fn main() {
    // Get a input from a File, standard input, or others
    // Input can be `&str`, `String`, `&[u8]`, or `Vec<u8>`
    let sample_input = "Hello,    byte_reader!";

    // Create mutable `r`
    let mut r = Reader::new(sample_input);

    // Use some simple operations
    // to parse the input
    r.consume("Hello").unwrap();
    r.consume(",").unwrap();
    r.skip_whitespace();
    let name = r.read_snake().unwrap(); // byte_reader
    r.consume("!").unwrap();

    println!("Greeted to `{name}`.");
}

pub fn read_while(&mut self, condition: impl Fn(&u8) -> bool) -> &[u8]

Read next byte while the condition holds on it

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

Read next one byte, or return None if the remained bytes is empty

pub fn next_if(&mut self, condition: impl Fn(&u8) -> bool) -> Option<u8>

Read next one byte if the condition holds on it

pub fn peek(&self) -> Option<&u8>

Peek next byte (without consuming)

pub fn peek2(&self) -> Option<&u8>

Peek next byte of next byte (without consuming)

pub fn peek3(&self) -> Option<&u8>

Peek next byte of next byte of next byte (without consuming)

pub fn consume(&mut self, token: impl Bytes) -> Option<()>

Read token if the remained bytes starts with it, otherwise return Err

token :　&str | String | &[u8] | Vec<u8>

Examples found in repository

examples/usage.rs (line 13)

fn main() {
    // Get a input from a File, standard input, or others
    // Input can be `&str`, `String`, `&[u8]`, or `Vec<u8>`
    let sample_input = "Hello,    byte_reader!";

    // Create mutable `r`
    let mut r = Reader::new(sample_input);

    // Use some simple operations
    // to parse the input
    r.consume("Hello").unwrap();
    r.consume(",").unwrap();
    r.skip_whitespace();
    let name = r.read_snake().unwrap(); // byte_reader
    r.consume("!").unwrap();

    println!("Greeted to `{name}`.");
}

pub fn consume_oneof<const N: usize>( &mut self, tokens: [impl Bytes; N] ) -> Option<usize>

Read first token in tokens that the remained bytes starts with, and returns the index of the (matched) token, or Err if none matched

token :　&str | String | &[u8] | Vec<u8>

pub fn read_camel(&mut self) -> Option<String>

Read a camelCase word like helloWorld, userID, … as String

pub fn read_snake(&mut self) -> Option<String>

Read a snake_case word like hello_world, user_id, … as String

Examples found in repository

examples/usage.rs (line 16)

fn main() {
    // Get a input from a File, standard input, or others
    // Input can be `&str`, `String`, `&[u8]`, or `Vec<u8>`
    let sample_input = "Hello,    byte_reader!";

    // Create mutable `r`
    let mut r = Reader::new(sample_input);

    // Use some simple operations
    // to parse the input
    r.consume("Hello").unwrap();
    r.consume(",").unwrap();
    r.skip_whitespace();
    let name = r.read_snake().unwrap(); // byte_reader
    r.consume("!").unwrap();

    println!("Greeted to `{name}`.");
}

pub fn read_kebab(&mut self) -> Option<String>

Read a kebeb-case word like hello-world, Content-Type, … as String

pub fn read_string(&mut self) -> Option<String>

Read a double-quoted UTF-8 string literal like "Hello, world!", "application/json", … and return the quoted content as String

• Returns None if

  • Expected "s were not found
  • The quoted content is not UTF-8

• This doesn’t handle escape sequences

pub unsafe fn read_string_unchecked(&mut self) -> Option<String>

Read a double-quoted string literal like "Hello, world!", "application/json", … the and return the quoted content as String without checking if the content bytes is valid UTF-8

This doesn’t handle escape sequences

pub fn read_uint(&mut self) -> Option<usize>

Read an unsigned integer literal like 42, 123 if found, and return it as usize

• Panics if the integer is larger then usize::MAX

pub fn read_int(&mut self) -> Option<isize>

Read an integer literal like 42, -1111 if found, and return it as isize

• Panics if the integer is larger then isize::MAX or smaller then isize::MIN