Struct snekdown::parsing::parser::Parser

pub struct Parser { /* fields omitted */ }

Implementations

impl Parser

pub fn new_from_file(path: String) -> Result<Self, Error>

TODO fn get_until(until: &char, err_when: &[]) -> String

pub fn new(text: String, path: Option<String>) -> Self

pub fn new_as_child(
    text: String,
    path: String,
    paths: Arc<Mutex<Vec<String>>>
) -> Self

pub fn parse(&mut self) -> Document

parses the given text into a document

pub fn parse_block(&mut self) -> Result<Block, ParseError>

Parses a block Token

pub fn parse_row(&mut self) -> Result<Row, ParseError>

parses a table row/head

Trait Implementations

impl CharStateMachine for Parser

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

Increments the current index and returns the char at the indexes position

fn skip_char(&mut self)

skips to the next char

fn revert_to(&mut self, index: usize) -> Result<(), ParseError>

Returns to an index position

fn revert_with_error(&mut self, index: usize) -> ParseError

reverts and returns a parse error

fn seek_inline_whitespace(&mut self)

Skips characters until it encounters a character that isn't an inline whitespace character

fn seek_whitespace(&mut self)

Skips characters until it encounters a character that isn't a whitespace character

fn check_escaped(&self) -> bool

checks if the input character is escaped

fn check_special(&self, character: &char) -> bool

checks if the current character is the given input character and not escaped

fn check_special_group(&self, chars: &[char]) -> bool

checks if the current character is part of the given group

fn check_special_sequence_group(&mut self, sequences: &[&[char]]) -> bool

checks if the next chars are a special sequence

fn check_linebreak(&self) -> bool

returns if the current character is a linebreak character Note: No one likes CRLF

fn check_seek_inline_whitespace(&mut self) -> bool

seeks inline whitespaces and returns if there were seeked whitespaces

fn check_special_sequence(&mut self, sequence: &[char]) -> bool

checks if the next characters match a special sequence

fn get_string_until(
    &mut self,
    break_at: &[char],
    err_at: &[char]
) -> Result<String, ParseError>

returns the string until a specific

fn get_string_until_sequence(
    &mut self,
    break_at: &[&[char]],
    err_at: &[char]
) -> Result<String, ParseError>

Returns the string until a specific end sequence or an error character

fn assert_special(
    &mut self,
    character: &char,
    revert_index: usize
) -> Result<(), ParseError>

fn assert_special_group(
    &mut self,
    group: &[char],
    revert_index: usize
) -> Result<(), ParseError>

fn assert_special_sequence(
    &mut self,
    sequence: &[char],
    revert_index: usize
) -> Result<(), ParseError>

fn assert_special_sequence_group(
    &mut self,
    sequences: &[&[char]],
    revert_index: usize
) -> Result<(), ParseError>

fn seek_until_linebreak(&mut self)