Struct pex::ParseState

pub struct ParseState<'i> {
    pub residual: &'i str,
    pub start_offset: usize,
    pub stop_reason: Option<StopBecause>,
}

The state of parsing

Fields

residual: &'i str

Rest part of string

start_offset: usize

Start offset of the string

stop_reason: Option<StopBecause>

Stop reason

Implementations

impl<'i> ParseState<'i>

pub fn advance<T>(self, term: T) -> ParseState<'i>where T: Into<ParseAdvance>,

Advance the parser to a new state.

pub fn advance_view(self, offset: usize) -> ParseResult<'i, &'i str>

Advance the parser state and return the view of these string.

impl<'i> ParseState<'i>

Character parsing methods.

pub fn match_char(self, target: char) -> ParseResult<'i, char>

Match a single character.

'c'

pub fn match_char_range(self, start: char, end: char) -> ParseResult<'i, char>

Match a character in given range.

[a-z]

pub fn match_eof(self) -> ParseResult<'i, ()>

Assert end of file

p $

pub fn match_char_any(self) -> ParseResult<'i, char>

Match any character, except EOF.

pub fn match_char_if<F>( self, predicate: F, message: &'static str ) -> ParseResult<'i, char>where F: FnMut(char) -> bool,

Parsing a character with given rule.

impl<'i> ParseState<'i>

pub fn match_str_pattern<'a, 'p, P>( self, target: P, message: &'static str ) -> ParseResult<'i, &'i str>where P: Pattern<'p>, 'i: 'p,

Match a static string pattern.

pub fn match_str<'a>(self, target: &'static str) -> ParseResult<'i, &'i str>

Match a static string.

pub fn match_str_insensitive( self, target: &'static str ) -> ParseResult<'i, &'i str>

Match a static string.

pub fn match_regex( &self, re: &Regex, message: &'static str ) -> ParseResult<'i, Match<'_>>

Match a string with given regex.

pub fn match_str_if<F>( self, predicate: F, message: &'static str ) -> ParseResult<'i, &'i str>where F: FnMut(char) -> bool,

Match a string with given conditional.

pub fn match_str_until<F>( self, predicate: F, message: &'static str ) -> ParseResult<'i, &'i str>where F: FnMut(char) -> bool,

Match a string with given conditional.

impl<'i> ParseState<'i>

pub fn match_fn<T, F>(self, parse: F) -> ParseResult<'i, T>where F: FnMut(ParseState<'i>) -> ParseResult<'_, T>,

Simple suffix call form

pub fn match_repeats<T, F>(self, parse: F) -> ParseResult<'i, Vec<T>>where F: FnMut(ParseState<'i>) -> ParseResult<'_, T>,

Parses a sequence of 0 or more repetitions of the given parser.

p*
p+ <=> p p*

pub fn match_repeat_m_n<T, F>( self, min: usize, max: usize, parse: F ) -> ParseResult<'i, Vec<T>>where F: FnMut(ParseState<'i>) -> ParseResult<'_, T>,

Parses a sequence of 0 or more repetitions of the given parser.

p* <=> p{0, \inf}
p+ <=> p{1, \inf}
p{min, max}

pub fn match_optional<T, F>(self, parse: F) -> ParseResult<'i, Option<T>>where F: FnMut(ParseState<'i>) -> ParseResult<'_, T>,

Parse an optional element

p?

pub fn skip<F, T>(self, parse: F) -> ParseState<'i>where F: FnMut(ParseState<'i>) -> ParseResult<'_, T>,

Match but does not return the result

pub fn match_positive<F, T>( self, parse: F, message: &'static str ) -> ParseResult<'i, ()>where F: FnMut(ParseState<'i>) -> ParseResult<'_, T>,

Zero-width positive match, does not consume input

Used to be a external rule, which used as assert

&ahead p
p &after

pub fn match_negative<F, T>( self, parse: F, message: &'static str ) -> ParseResult<'i, ()>where F: FnMut(ParseState<'i>) -> ParseResult<'_, T>,

Zero-width negative match, does not consume input

!ahead p
p !after

impl<'i> ParseState<'i>

pub fn begin_choice<T>(self) -> ChoiceHelper<'i, T>

Begin a choice progress

impl<'i> ParseState<'i>

pub const fn new(input: &'i str) -> Self

Create a new state

pub const fn with_start_offset(self, offset: usize) -> Self

Reset the cursor offset

pub const fn end_offset(&self) -> usize

Reset the cursor offset

pub const fn finish<T>(self, value: T) -> ParseResult<'i, T>

Finish with given value

pub const fn is_empty(&self) -> bool

Check if the string is depleted

pub const fn get_error(self) -> StopBecause

Get inner error

pub const fn set_error(&mut self, error: StopBecause)

Set inner error

pub fn get_string<R>(&self, range: R) -> Option<&R::Output>where R: SliceIndex<str>,

Get a string view

pub fn get_character(&self, nth: usize) -> Option<char>

Get nth character

pub const fn away_from(&self, start: ParseState<'_>) -> Range<usize>

Get range away from start state

Trait Implementations

impl<'i> Clone for ParseState<'i>

fn clone(&self) -> ParseState<'i>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'i> Debug for ParseState<'i>

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

Formats the value using the given formatter.

impl<'i> PartialEq<ParseState<'i>> for ParseState<'i>

fn eq(&self, other: &ParseState<'i>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'i> Copy for ParseState<'i>

impl<'i> Eq for ParseState<'i>

impl<'i> StructuralEq for ParseState<'i>

impl<'i> StructuralPartialEq for ParseState<'i>