Enum fancy_regex::Expr

pub enum Expr {
    Empty,
    Any {
        newline: bool,
    },
    StartText,
    EndText,
    StartLine,
    EndLine,
    Literal {
        val: String,
        casei: bool,
    },
    Concat(Vec<Expr>),
    Alt(Vec<Expr>),
    Group(Box<Expr>),
    LookAround(Box<Expr>, LookAround),
    Repeat {
        child: Box<Expr>,
        lo: usize,
        hi: usize,
        greedy: bool,
    },
    Delegate {
        inner: String,
        size: usize,
        casei: bool,
    },
    Backref(usize),
    AtomicGroup(Box<Expr>),
}

Regular expression AST. This is public for now but may change.

Variants

Empty

An empty expression, e.g. the last branch in (a|b|)

Any

Any character, regex .

Fields of Any

newline: bool

Whether it also matches newlines or not

StartText

Start of input text

EndText

End of input text

StartLine

Start of a line

EndLine

End of a line

Literal

The string as a literal, e.g. a

Fields of Literal

val: String

The string to match

casei: bool

Whether match is case-insensitive or not

Concat(Vec<Expr>)

Concatenation of multiple expressions, must match in order, e.g. a. is a concatenation of the literal a and . for any character

Alt(Vec<Expr>)

Alternative of multiple expressions, one of them must match, e.g. a|b is an alternative where either the literal a or b must match

Group(Box<Expr>)

Capturing group of expression, e.g. (a.) matches a and any character and "captures" (remembers) the match

LookAround(Box<Expr>, LookAround)

Look-around (e.g. positive/negative look-ahead or look-behind) with an expression, e.g. (?=a) means the next character must be a (but the match is not consumed)

Repeat

Repeat of an expression, e.g. a* or a+ or a{1,3}

Fields of Repeat

child: Box<Expr>

The expression that is being repeated

lo: usize

The minimum number of repetitions

hi: usize

The maximum number of repetitions (or usize::MAX)

greedy: bool

Greedy means as much as possible is matched, e.g. .*b would match all of abab. Non-greedy means as little as possible, e.g. .*?b would match only ab in abab.

Delegate

Delegate a regex to the regex crate. This is used as a simplification so that we don't have to represent all the expressions in the AST, e.g. character classes.

Fields of Delegate

inner: String

The regex

size: usize

How many characters the regex matches

casei: bool

Whether the matching is case-insensitive or not

Backref(usize)

Back reference to a capture group, e.g. \1 in (abc|def)\1 references the captured group and the whole regex matches either abcabc or defdef.

AtomicGroup(Box<Expr>)

Atomic non-capturing group, e.g. (?>ab|a) in text that contains ab will match ab and never backtrack and try a, even if matching fails after the atomic group.

Methods

impl Expr

pub fn parse(re: &str) -> Result<(Expr, BitSet)>

Parse the regex and return an expression (AST) and a bit set with the indexes of groups that are referenced by backrefs.

pub fn to_str(&self, buf: &mut String, precedence: u8)

Convert expression to a regex string in the regex crate's syntax.

Panics

Panics for expressions that are hard, i.e. can not be handled by the regex crate.

Trait Implementations

impl Eq for Expr

impl PartialEq<Expr> for Expr

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

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

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

This method tests for !=.

impl Debug for Expr

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

Formats the value using the given formatter.