Enum Node

pub enum Node {
    Empty,
    Disjunction(Span, Vec<Node>),
    Assertion(Span, AssertionKind),
    Alternative(Span, Vec<Node>),
    Literal(Span, char, String),
    PerlClass(Span, ClassPerlKind, bool),
    BackReference(Span, u32),
    Dot(Span),
    CharacterClass(Span, CharacterClass),
    Group(Span, Group),
    Quantifier(Span, Box<Node>, QuantifierKind, bool),
    NamedBackReference(Span, String),
}

The tree structure that is used to represent parsed RegEx patterns.

Variants

Empty

An empty regex node.

Disjunction(Span, Vec<Node>)

An “either or”. (e.g. a|b)

Assertion(Span, AssertionKind)

A single assertion.

Alternative(Span, Vec<Node>)

A concatenation of regex nodes. (e.g. ab)

Literal(Span, char, String)

A single character literal. The String represents the raw string representing the literal which is used to turn the node back into a string without writing explicit newlines for example.

PerlClass(Span, ClassPerlKind, bool)

Matches a character class (e.g. \d or \w).

The bool argument indicates if this perl class is negated.

BackReference(Span, u32)

A back reference to a previous group (\1, \2, …).

Dot(Span)

A . that matches everything.

CharacterClass(Span, CharacterClass)

A class of multiple characters such as [A-Z0-9]

Group(Span, Group)

A grouped pattern

Quantifier(Span, Box<Node>, QuantifierKind, bool)

A quantifier which optionally matches or matches multiple times. bool indicates whether a lazy quantifier (?) is present after it.

NamedBackReference(Span, String)

A reference to a group using a name

Implementations

impl Node

pub fn expanded_nodes(&mut self) -> Box<dyn Iterator<Item = &mut Node> + '_>

if this node is an alternative, yield an iterator over those nodes, otherwise yield the node itself.

pub fn span(&self) -> Option<Span>

get the span of this node, returns None if the node is an empty node.

pub fn is(&self, src: impl AsRef<str>, text: impl AsRef<str>) -> bool

check if this node is equal to some text

pub fn text<'a>(&self, src: &'a str) -> &'a str

pub fn from_string(string: impl AsRef<str>) -> Option<Self>

create a new node from a string. This method is mostly just used for making simple nodes for replacement.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl ToString for Node

fn to_string(&self) -> String

Converts the given value to a String.

impl Eq for Node

impl StructuralPartialEq for Node