Enum regex_syntax::Expr [] [src]

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
[src]

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
[src]

impl PartialEq for Expr
[src]

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

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

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

This method tests for !=.

impl Debug for Expr
[src]

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

Formats the value using the given formatter.

impl Clone for Expr
[src]

fn clone(&self) -> Expr

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

impl Display for Expr
[src]

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.