Enum rslint_regex::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)

Tuple Fields of Disjunction

0: Span1: Vec<Node>

Assertion(Span, AssertionKind)

A single assertion.

Tuple Fields of Assertion

0: Span1: AssertionKind

Alternative(Span, Vec<Node>)

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

Tuple Fields of Alternative

0: Span1: Vec<Node>

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.

Tuple Fields of Literal

0: Span1: char2: String

PerlClass(Span, ClassPerlKind, bool)

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

The bool argument indicates if this perl class is negated.

Tuple Fields of PerlClass

0: Span1: ClassPerlKind2: bool

BackReference(Span, u32)

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

Tuple Fields of BackReference

0: Span1: u32

Dot(Span)

A . that matches everything.

Tuple Fields of Dot

0: Span

CharacterClass(Span, CharacterClass)

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

Tuple Fields of CharacterClass

0: Span1: CharacterClass

Group(Span, Group)

A grouped pattern

Tuple Fields of Group

0: Span1: Group

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.

Tuple Fields of Quantifier

0: Span1: Box<Node>2: QuantifierKind3: bool

NamedBackReference(Span, String)

A reference to a group using a name

Tuple Fields of NamedBackReference

0: Span1: String

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 copy 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<Node> for Node

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

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

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

This method tests for !=.

impl ToString for Node

fn to_string(&self) -> String

Converts the given value to a String.

impl Eq for Node

impl StructuralEq for Node

impl StructuralPartialEq for Node