Struct json_peek::lexer::Lexer

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

A Token Lexer which take string and convert it into a list of Token

let content = r#"{"foo": 1}"#;
let lexer = Lexer::new(content);
 
let tokens = lexer.lex();

You are probably getting tired of bad documentation like this so here's megumin:

Methods

impl<'a> Lexer<'a>

pub const fn new(source: &'a str) -> Lexer<'a>

Create Lexer to source

let content = r#"{ "foo": null, "bar": false }"#;
let lexer = Lexer::new(content);
let mut token = lexer.into_iter();

// Note: `Token::test_*()` function create a token without position information cause I'm too lazy to do it
assert_eq!(token.next(), Some(Token::test_symbol("{")));
assert_eq!(token.next(), Some(Token::test_string("foo")));
assert_eq!(token.next(), Some(Token::test_symbol(":")));
assert_eq!(token.next(), Some(Token::test_identifier("null")));
assert_eq!(token.next(), Some(Token::test_symbol(",")));
assert_eq!(token.next(), Some(Token::test_string("bar")));
assert_eq!(token.next(), Some(Token::test_symbol(":")));
assert_eq!(token.next(), Some(Token::test_identifier("false")));
assert_eq!(token.next(), Some(Token::test_symbol("}")));
assert_eq!(token.next(), None);

pub fn lex(self) -> Vec<Token<'a>>

Easily create a Vec of Token

Trait Implementations

impl<'a> Clone for Lexer<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Lexer<'a>

impl<'a> Debug for Lexer<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for Lexer<'a>

impl<'a> IntoIterator for Lexer<'a>

type Item = Token<'a>

The type of the elements being iterated over.

type IntoIter = LexerIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Convert Lexer into iterator of Token.
See: LexerIter

impl<'a> PartialEq<Lexer<'a>> for Lexer<'a>

fn eq(&self, other: &Lexer<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Lexer<'a>) -> bool

This method tests for !=.

impl<'a> StructuralEq for Lexer<'a>

impl<'a> StructuralPartialEq for Lexer<'a>