Struct parser_compose::ParserContext

pub struct ParserContext<T> { /* private fields */ }

Container for input into parsers

All parsers accept a ParserContext as input and must return one if they succeed.

The structure contains whatever input is yet to be parsed as well as our absolute position within the original input, which is useful for reporting errors.

Note: if you are manually extracting the values from the input, you will need to update the position before returning the context. An example will clarify:

use parser_compose::{Parser, ParserContext, Res};

fn easy(ctx: ParserContext<&str>) -> Res<&str, (&str, &str)> {
    // Here, the sequence combinator will take care of updating the context
    // before returning if both parsers matched.
    ("A", "B").try_parse(ctx)
}

fn manual(mut ctx: ParserContext<&str>) -> Res<&str, &str> {
    let (offset, _) = ("A", "B").peek().try_parse(ctx)?;

    // In some cases, you might want to manually extract the value yourself.
    // In this contrived example, doing so lets you return a single string
    // slice instead of a tuple.
    let value = &ctx.input()[..offset];
    // But make sure you update the position in the context before passing it on
    ctx.advance_by(offset);

    Ok((value, ctx))
}

let msg = "AB";

let (value, rest) = easy.try_parse(msg.into()).unwrap();

assert_eq!(value, ("A", "B"));
assert_eq!(rest.input(), "");

let (value, rest) = manual.try_parse(msg.into()).unwrap();
assert_eq!(value, "AB");
assert_eq!(rest.input(), "");

Regular slices (i.e. &[T]) and string slices (i.e. &str) can be converted into this structure by using ParserContext::from(), or using .into() in contexts where the compiler can infer the type.

Implementations

impl<'a, T> ParserContext<&'a T>where T: Index<RangeFrom<usize>> + ?Sized,

pub fn input(&self) -> &'a <T as Index<RangeFrom<usize>>>::Output

Returns the input being parsed. The first parser will see the entire input. Subsequent parsers will only see whatever is left to parse

impl<T> ParserContext<T>where T: Clone,

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

Increments the input position by count. If there is less than count elements left in the input, the position will be set to the length of the input.

Advancing the position affects what subsequent calls to .input() return

impl<T> ParserContext<T>

pub fn end_of_input(&self) -> bool

Returns true if this instance’s position is at the end of the input

pub fn get_position(&self) -> usize

Returns the current input position

Trait Implementations

impl<T: Clone> Clone for ParserContext<T>

fn clone(&self) -> ParserContext<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ParserContext<T>

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

Formats the value using the given formatter.

impl<'i, T> From<&'i [T]> for ParserContext<&'i [T]>

fn from(value: &'i [T]) -> Self

Converts to this type from the input type.

impl<'i> From<&'i str> for ParserContext<&'i str>

fn from(value: &'i str) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for ParserContext<T>

fn eq(&self, other: &ParserContext<T>) -> 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<T: Copy> Copy for ParserContext<T>

impl<T: Eq> Eq for ParserContext<T>

impl<T> StructuralEq for ParserContext<T>

impl<T> StructuralPartialEq for ParserContext<T>