Enum AstNode 

pub enum AstNode {
    Literal(char),
    CharClass(CharClass),
    StartAnchor,
    EndAnchor,
    WordBoundary,
    StartWord,
    EndWord,
    SetMatchStart,
    SetMatchEnd,
    ZeroOrMore {
        node: Box<AstNode>,
        greedy: bool,
    },
    OneOrMore {
        node: Box<AstNode>,
        greedy: bool,
    },
    Optional {
        node: Box<AstNode>,
        greedy: bool,
    },
    Exact {
        node: Box<AstNode>,
        count: usize,
    },
    Range {
        node: Box<AstNode>,
        min: usize,
        max: Option<usize>,
        greedy: bool,
    },
    Group {
        nodes: Vec<AstNode>,
        name: Option<String>,
        capture: bool,
        index: Option<usize>,
    },
    Alternation(Vec<Vec<AstNode>>),
    Backref(usize),
    LookAhead {
        nodes: Vec<AstNode>,
        positive: bool,
    },
    LookBehind {
        nodes: Vec<AstNode>,
        positive: bool,
    },
}

Represents a node in the Abstract Syntax Tree (AST) of a regular expression.

Variants

Literal(char)

A literal character match.

CharClass(CharClass)

A character class (e.g., \d, [a-z], .).

StartAnchor

Start of string (or line in multiline mode) anchor ^.

EndAnchor

End of string (or line in multiline mode) anchor $.

WordBoundary

Word boundary anchor \b.

StartWord

Start of word anchor \<.

EndWord

End of word anchor \>.

SetMatchStart

Sets the start of the match \zs.

SetMatchEnd

Sets the end of the match \ze.

ZeroOrMore

Zero or more repetitions *.

Fields

node: Box<AstNode>

The node being repeated.

greedy: bool

Whether the quantifier is greedy (default) or lazy (?).

OneOrMore

One or more repetitions +.

Fields

node: Box<AstNode>

The node being repeated.

greedy: bool

Whether the quantifier is greedy (default) or lazy (?).

Optional

Zero or one repetition ?.

Fields

node: Box<AstNode>

The node being repeated.

greedy: bool

Whether the quantifier is greedy (default) or lazy (?).

Exact

Exact number of repetitions {n}.

Fields

node: Box<AstNode>

The node being repeated.

count: usize

The exact count.

Range

Range of repetitions {n,m} or {n,}.

Fields

node: Box<AstNode>

The node being repeated.

min: usize

The minimum count.

max: Option<usize>

The maximum count (None means infinite).

greedy: bool

Whether the quantifier is greedy (default) or lazy (?).

Group

A capturing or non-capturing group (...).

Fields

nodes: Vec<AstNode>

The sequence of nodes inside the group.

name: Option<String>

The name of the group, if it is a named capture (?<name>...).

capture: bool

Whether this group captures text.

index: Option<usize>

The index of the capture group (1-based), if capturing.

Alternation(Vec<Vec<AstNode>>)

Alternation |.

Backref(usize)

Backreference to a captured group \n.

LookAhead

Lookahead assertion (?>=...) or (?>!...).

Fields

nodes: Vec<AstNode>

The sequence of nodes to check ahead.

positive: bool

True for positive lookahead, false for negative.

LookBehind

Lookbehind assertion (?<=...) or (?<!...).

Fields

nodes: Vec<AstNode>

The sequence of nodes to check behind.

positive: bool

True for positive lookbehind, false for negative.

Trait Implementations

impl Clone for AstNode

fn clone(&self) -> AstNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AstNode

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

Formats the value using the given formatter.

impl PartialEq for AstNode

fn eq(&self, other: &AstNode) -> 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 StructuralPartialEq for AstNode