Enum piston_meta::Rule

pub enum Rule {
    Whitespace(Whitespace),
    Tag(Tag),
    UntilAny(UntilAny),
    UntilAnyOrWhitespace(UntilAnyOrWhitespace),
    Text(Text),
    Number(Number),
    Select(Select),
    FastSelect(Box<FastSelect>),
    Sequence(Sequence),
    SeparateBy(Box<SeparateBy>),
    Repeat(Box<Repeat>),
    Lines(Box<Lines>),
    Node(Node),
    Optional(Box<Optional>),
    Not(Box<Not>),
}

A rule describes how some section of a document should be parsed.

Variants

Whitespace(Whitespace)

Read whitespace.

Tag(Tag)

Match against a tag.

UntilAny(UntilAny)

Reads until any character.

UntilAnyOrWhitespace(UntilAnyOrWhitespace)

Read until any character or whitespace.

Text(Text)

Read text.

Number(Number)

Read number.

Select(Select)

Select one of the sub rules. If the first one does not succeed, try another and so on. If all sub rules fail, then the rule fails.

FastSelect(Box<FastSelect>)

Select one of the sub rules, using fast table lookup.

Sequence(Sequence)

Run each sub rule in sequence. If any sub rule fails, the rule fails.

SeparateBy(Box<SeparateBy>)

Repeat rule separated by another rule.

Repeat(Box<Repeat>)

Repeat rule.

Lines(Box<Lines>)

Repeat rule separated by one or more lines.

Node(Node)

Read node.

Optional(Box<Optional>)

Read optional.

Not(Box<Not>)

Read not.

Implementations

impl Rule

pub fn parse(
    &self,
    tokens: &mut Vec<Range<MetaData>>,
    state: &TokenizerState,
    read_token: &ReadToken<'_>,
    refs: &[Rule],
    indent_settings: &mut IndentSettings
) -> ParseResult<TokenizerState>

Parses rule.

pub fn update_refs(&mut self, names: &[Arc<String>])

Updates replacing names with the references.

The references contains the name, but this can not be borrowed as when the same reference is updated.

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.

impl PartialEq<Rule> for Rule

fn eq(&self, other: &Rule) -> bool

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

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

This method tests for !=.

impl StructuralPartialEq for Rule