[−][src]Trait snekdown::parsing::charstate::CharStateMachine

pub trait CharStateMachine {
    fn next_char(&mut self) -> Option<char>;

    fn skip_char(&mut self);

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

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

    fn seek_inline_whitespace(&mut self);

    fn seek_whitespace(&mut self);

    fn seek_until_linebreak(&mut self);

    fn check_seek_inline_whitespace(&mut self) -> bool;

    fn check_escaped(&self) -> bool;

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

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

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

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

    fn check_linebreak(&self) -> bool;

    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 get_string_until(
        &mut self, 
        break_at: &[char], 
        err_at: &[char]
    ) -> Result<String, ParseError>;

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

    fn get_string_until_or_revert(
        &mut self, 
        break_et: &[char], 
        err_at: &[char], 
        revert_index: usize
    ) -> Result<String, ParseError>;
}

Required methods

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

fn skip_char(&mut self)

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

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

fn seek_inline_whitespace(&mut self)

fn seek_whitespace(&mut self)

fn seek_until_linebreak(&mut self)

fn check_seek_inline_whitespace(&mut self) -> bool

fn check_escaped(&self) -> bool

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

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

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

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

fn check_linebreak(&self) -> bool

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 get_string_until(
    &mut self,
    break_at: &[char],
    err_at: &[char]
) -> Result<String, ParseError>

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

fn get_string_until_or_revert(
    &mut self,
    break_et: &[char],
    err_at: &[char],
    revert_index: usize
) -> Result<String, ParseError>

Loading content...

Implementors

impl CharStateMachine for Parser[src]

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

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

fn skip_char(&mut self)[src]

skips to the next char

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

Returns to an index position

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

reverts and returns a parse error

fn seek_inline_whitespace(&mut self)[src]

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

fn seek_whitespace(&mut self)[src]

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

fn seek_until_linebreak(&mut self)[src]

seeks until it encounters a linebreak character

fn check_seek_inline_whitespace(&mut self) -> bool[src]

seeks inline whitespaces and returns if there were seeked whitespaces

fn check_escaped(&self) -> bool[src]

checks if the input character is escaped

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

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

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

checks if the current character is part of the given group

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

checks if the next characters match a special sequence

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

checks if the next chars are a special sequence

fn check_linebreak(&self) -> bool[src]

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

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

returns the string until a specific

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

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

fn get_string_until_or_revert(
    &mut self,
    break_at: &[char],
    err_at: &[char],
    revert_index: usize
) -> Result<String, ParseError>[src]

returns the string until a specific character or reverts back to the given position

Loading content...