Enum regex_syntax::Expr

pub enum Expr {
    Empty,
    Literal {
        chars: Vec<char>,
        casei: bool,
    },
    AnyChar,
    AnyCharNoNL,
    Class(CharClass),
    StartLine,
    EndLine,
    StartText,
    EndText,
    WordBoundary,
    NotWordBoundary,
    Group {
        e: Box<Expr>,
        i: Option<usize>,
        name: Option<String>,
    },
    Repeat {
        e: Box<Expr>,
        r: Repeater,
        greedy: bool,
    },
    Concat(Vec<Expr>),
    Alternate(Vec<Expr>),
}

A regular expression abstract syntax tree.

An Expr represents the abstract syntax of a regular expression.

Variants

Empty

An empty regex (which never matches any text).

Literal

A sequence of one or more literal characters to be matched.

Fields

chars: Vec<char>	The characters.
casei: bool	Whether to match case insensitively.

AnyChar

Match any character.

AnyCharNoNL

Match any character, excluding new line.

Class(CharClass)

A character class.

StartLine

Match the start of a line or beginning of input.

EndLine

Match the end of a line or end of input.

StartText

Match the beginning of input.

EndText

Match the end of input.

WordBoundary

Match a word boundary (word character on one side and a non-word character on the other).

NotWordBoundary

Match a position that is not a word boundary (word or non-word characters on both sides).

Group

A group, possibly non-capturing.

Fields

e: Box<Expr>	The expression inside the group.
i: Option<usize>	The capture index (starting at 1) only for capturing groups.
name: Option<String>	The capture name, only for capturing named groups.

Repeat

A repeat operator (?, *, + or {m,n}).

Fields

e: Box<Expr>	The expression to be repeated. Limited to literals, ., classes or grouped expressions.
r: Repeater	The type of repeat operator used.
greedy: bool	Whether the repeat is greedy (match the most) or not (match the least).

Concat(Vec<Expr>)

A concatenation of expressions. Must be matched one after the other.

N.B. A concat expression can only appear at the top-level or immediately inside a group expression.

Alternate(Vec<Expr>)

An alternation of expressions. Only one must match.

N.B. An alternate expression can only appear at the top-level or immediately inside a group expression.

Methods

impl Expr

fn parse(s: &str) -> Result<Expr>

Parses a string in a regular expression syntax tree.

This is a convenience method for parsing an expression using the default configuration. To tweak parsing options (such as which flags are enabled by default), use the ExprBuilder type.

fn is_anchored_start(&self) -> bool

Returns true if and only if the expression is required to match from the beginning of text.

fn is_anchored_end(&self) -> bool

Returns true if and only if the expression is required to match at the end of the text.

Trait Implementations

impl Eq for Expr

impl PartialEq for Expr

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

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

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

This method tests for !=.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Display for Expr

This implementation of Display will write a regular expression from the syntax tree. It does not write the original string parsed.

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

Formats the value using the given formatter.