Enum RegexNode

pub enum RegexNode {
    And(Vec<RegexId>),
    Or(Vec<RegexId>),
    Concat(Vec<RegexId>),
    LookAhead(RegexId),
    Not(RegexId),
    Repeat(RegexId, u32, Option<u32>),
    EmptyString,
    NoMatch,
    Regex(String),
    Literal(String),
    ByteLiteral(Vec<u8>),
    Byte(u8),
    ByteSet(Vec<u32>),
}

Variants

And(Vec<RegexId>)

Intersection of the regexes

Or(Vec<RegexId>)

Union of the regexes

Concat(Vec<RegexId>)

Concatenation of the regexes

LookAhead(RegexId)

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

Not(RegexId)

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

Repeat(RegexId, u32, Option<u32>)

Repeat the regex at least min times, at most max times

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

Trait Implementations

impl Clone for RegexNode

fn clone(&self) -> RegexNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RegexNode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RegexNode

fn deserialize<__D>( __deserializer: __D, ) -> Result<RegexNode, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for RegexNode

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RegexNode

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RegexNode

impl StructuralPartialEq for RegexNode