Struct yaml_peg::parser::Loader

pub struct Loader<'a, R: Repr> {
    pub parser: Parser<'a>,
    /* private fields */
}

A parser with YAML grammar, support UTF-8 characters.

This loader will output YAML nodes with representation notation repr::Repr. If you just want to use sub-parser, please see Parser.

A simple example for parsing YAML only:

use yaml_peg::{node, parser::Loader};

let n = Loader::new(b"true").parse().unwrap();
assert_eq!(n, vec![node!(true)]);

For matching partial grammar, each methods are the sub-parser. The methods have some behaviors:

• They will move the current cursor if matched.
• Returned value:
  • Result<(), PError> represents the sub-parser can be matched and mismatched.
  • PError represents the sub-parser can be totally breaked when mismatched.
• Use ? to match a condition.
• Use Result::unwrap_or_default to match an optional condition.
• Method Parser::forward is used to move on.
• Method Parser::text is used to get the matched string.
• Method Parser::backward is used to get back if mismatched.

Fields

parser: Parser<'a>

Parser base.

Implementations

impl<'a, R: Repr> Loader<'a, R>

pub fn new(doc: &'a [u8]) -> Self

Create YAML loader includes a parser.

impl<R: Repr> Loader<'_, R>

The basic implementation.

These sub-parser returns PError, and failed immediately for PError::Terminate. Additionally, they should eat the string by themself.

Parameter nest

The nest parameter presents that the expression is in a map structure, includes grand parents.

If nest is false, the expression might in the document root.

Parameter inner

The inner parameter presents that the expression is in a flow expression.

pub fn keep_anchors(self, keep_anchors: bool) -> Self

Keep the anchor insertion.

This will make Yaml::Alias have a placeholder and adding anchor information in the Node.

pub fn get_anchors(self) -> Anchors<R>

Consume this loader and return the recorded anchors.

pub fn parse(&mut self) -> PResult<Vec<Node<R>>>

YAML entry point, return entire doc if exist.

pub fn doc(&mut self) -> PResult<Node<R>>

Match one doc block.

pub fn doc_end(&mut self) -> bool

Match doc end.

pub fn scalar(
    &mut self,
    level: usize,
    nest: bool,
    inner: bool
) -> PResult<Node<R>>

Match scalar.

pub fn scalar_flow(&mut self, level: usize, inner: bool) -> PResult<Node<R>>

Match flow scalar.

pub fn scalar_term(&mut self, level: usize, inner: bool) -> PResult<R::Ty>

Match flow scalar terminal.

pub fn seq_flow(&mut self, level: usize) -> PResult<R::Ty>

Match flow sequence.

pub fn map_flow(&mut self, level: usize) -> PResult<R::Ty>

Match flow map.

pub fn seq(&mut self, level: usize, nest: bool) -> PResult<R::Ty>

Match sequence.

pub fn map(&mut self, level: usize, nest: bool, inner: bool) -> PResult<R::Ty>

Match map.

Methods from Deref<Target = Parser<'a>>

pub fn directive(&mut self) -> PResult<()>

Match directives.

pub fn bound(&mut self) -> PResult<()>

Match invisible boundaries and keep the gaps. (must matched once)

pub fn complex_mapping(&mut self) -> PResult<()>

Match complex mapping indicator (?).

pub fn int(&mut self) -> PResult<String>

Match integer.

pub fn float(&mut self) -> PResult<String>

Match float.

pub fn sci_float(&mut self) -> PResult<String>

Match float with scientific notation.

pub fn string_quoted(&mut self, sym: u8, ignore: &[u8]) -> PResult<String>

Match quoted string.

pub fn string_plain(&mut self, level: usize, inner: bool) -> PResult<String>

Match plain string.

pub fn string_literal(&mut self, level: usize) -> PResult<String>

Match literal string.

pub fn string_folded(&mut self, level: usize) -> PResult<String>

Match folded string.

pub fn chomp(&mut self) -> impl Fn(String) -> String

Match chomping option.

pub fn string_wrapped(
    &mut self,
    level: usize,
    sep: u8,
    leading: bool
) -> PResult<String>

Match wrapped string.

pub fn identifier(&mut self) -> PResult<()>

Match valid YAML identifier.

pub fn tag(&mut self) -> PResult<String>

Match tags.

pub fn anchor(&mut self) -> PResult<String>

Match anchor definition.

pub fn anchor_use(&mut self) -> PResult<String>

Match anchor used.

pub fn ws(&mut self, opt: TakeOpt) -> PResult<()>

Match any invisible characters except newline.

pub fn nl(&mut self) -> PResult<()>

Match newline characters.

pub fn inv(&mut self, opt: TakeOpt) -> PResult<()>

Match any invisible characters.

pub fn ind_define(&mut self, level: usize) -> PResult<()>

Match and define new indent size.

pub fn unind(&mut self, level: usize) -> PResult<bool>

Match indent with previous level.

This sub-parser returns true if downgrading indent is used.

The downgrading can only use a level as unit, not a whitespace.

pub fn gap(&mut self, cmt: bool) -> PResult<usize>

Match any optional invisible characters between two lines.

Set cmt to true to ignore comments at the line end.

pub fn comment(&mut self) -> PResult<()>

Match comment.

pub fn food(&self) -> &'a [u8]

Show the right hand side string after the current cursor.

pub fn text(&mut self) -> String

Get the text from the eaten cursor to the current position.

pub fn indicator(&self) -> u64

Get the indicator.

pub fn err<R>(&self, name: &'static str) -> PResult<R>

A short function to raise error.

pub fn consume(&mut self)

Consume and move the pointer.

pub fn forward(&mut self)

Consume the eaten part.

pub fn backward(&mut self)

Move the current position back.

pub fn back(&mut self, n: usize)

Move back current cursor.

pub fn sym(&mut self, s: u8) -> PResult<()>

Match symbol.

pub fn sym_set(&mut self, s: &[u8]) -> PResult<()>

Match symbol set.

pub fn sym_seq(&mut self, s: &[u8]) -> PResult<()>

Match symbol sequence.

pub fn take_while<F>(&mut self, f: F, opt: TakeOpt) -> PResult<()> where
    F: Fn(&u8) -> bool, 

Match until the condition failed.

The argument opt matches different terminate requirement.

pub fn count<F, R>(&mut self, f: F) -> PResult<usize> where
    F: FnOnce(&mut Self) -> PResult<R>, 

Count the position that parser goes, expect error.

pub fn context<F, R>(&mut self, f: F) -> R where
    F: FnOnce(&mut Self) -> R, 

A wrapper for saving checkpoint locally.

pub fn ind(&mut self, level: usize) -> PResult<()>

Match indent.

Trait Implementations

impl<'a, R: Repr> Deref for Loader<'a, R>

type Target = Parser<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<R: Repr> DerefMut for Loader<'_, R>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.