Enum RegexAst

pub enum RegexAst {
    And(Vec<RegexAst>),
    Or(Vec<RegexAst>),
    Concat(Vec<RegexAst>),
    LookAhead(Box<RegexAst>),
    Not(Box<RegexAst>),
    Repeat(Box<RegexAst>, u32, u32),
    Prefixes(Box<RegexAst>),
    EmptyString,
    NoMatch,
    Regex(String),
    Literal(String),
    ByteLiteral(Vec<u8>),
    Byte(u8),
    ByteSet(Vec<u32>),
    ExprRef(ExprRef),
}

Variants

And(Vec<RegexAst>)

Intersection of the regexes

Or(Vec<RegexAst>)

Union of the regexes

Concat(Vec<RegexAst>)

Concatenation of the regexes

LookAhead(Box<RegexAst>)

Matches the regex; should be at the end of the main regex. The length of the lookahead can be recovered from the engine.

Not(Box<RegexAst>)

Matches everything the regex doesn’t match. Can lead to invalid utf8.

Repeat(Box<RegexAst>, u32, u32)

Repeat the regex at least min times, at most max times u32::MAX means infinity

Prefixes(Box<RegexAst>)

All prefixes of the words matched by the regex (including the empty string and the words themselves).

EmptyString

Matches the empty string. Same as Concat([]).

NoMatch

Matches nothing. Same as Or([]).

Regex(String)

Compile the regex using the regex_syntax crate

Literal(String)

Matches this string only

ByteLiteral(Vec<u8>)

Matches this string of bytes only. Can lead to invalid utf8.

Byte(u8)

Matches this byte only. If byte is not in 0..127, it may lead to invalid utf8

ByteSet(Vec<u32>)

Matches any byte in the set, expressed as bitset. Can lead to invalid utf8 if the set is not a subset of 0..127

ExprRef(ExprRef)

Reference previously built regex

Implementations

impl RegexAst

pub fn contained_in(&self, big: &RegexAst) -> RegexAst

Regex is empty iff self ⊆ big

pub fn get_args(&self) -> &[RegexAst]

pub fn tag(&self) -> &'static str

pub fn write_to_str(&self, dst: &mut String, max_len: usize)

Trait Implementations

impl Clone for RegexAst

fn clone(&self) -> RegexAst

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RegexAst

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

Formats the value using the given formatter.