Struct regex_automata::util::alphabet::Unit

pub struct Unit(UnitKind);

Unit represents a single unit of haystack for DFA based regex engines.

It is not expected for consumers of this crate to need to use this type unless they are implementing their own DFA. And even then, it’s not required: implementors may use other techniques to handle haystack units.

Typically, a single unit of haystack for a DFA would be a single byte. However, for the DFAs in this crate, matches are delayed by a single byte in order to handle look-ahead assertions (\b, $ and \z). Thus, once we have consumed the haystack, we must run the DFA through one additional transition using a unit that indicates the haystack has ended.

There is no way to represent a sentinel with a u8 since all possible values may be valid haystack units to a DFA, therefore this type explicitly adds room for a sentinel value.

The sentinel EOI value is always its own equivalence class and is ultimately represented by adding 1 to the maximum equivalence class value. So for example, the regex ^[a-z]+$ might be split into the following equivalence classes:

0 => [\x00-`]
1 => [a-z]
2 => [{-\xFF]
3 => [EOI]

Where EOI is the special sentinel value that is always in its own singleton equivalence class.

Tuple Fields

0: UnitKind

Implementations

impl Unit

pub fn u8(byte: u8) -> Unit

Create a new haystack unit from a byte value.

All possible byte values are legal. However, when creating a haystack unit for a specific DFA, one should be careful to only construct units that are in that DFA’s alphabet. Namely, one way to compact a DFA’s in-memory representation is to collapse its transitions to a set of equivalence classes into a set of all possible byte values. If a DFA uses equivalence classes instead of byte values, then the byte given here should be the equivalence class.

pub fn eoi(num_byte_equiv_classes: usize) -> Unit

Create a new “end of input” haystack unit.

The value given is the sentinel value used by this unit to represent the “end of input.” The value should be the total number of equivalence classes in the corresponding alphabet. Its maximum value is 256, which occurs when every byte is its own equivalence class.

Panics

This panics when num_byte_equiv_classes is greater than 256.

pub fn as_u8(self) -> Option<u8>

If this unit is not an “end of input” sentinel, then returns its underlying byte value. Otherwise return None.

pub fn as_eoi(self) -> Option<u16>

If this unit is an “end of input” sentinel, then return the underlying sentinel value that was given to Unit::eoi. Otherwise return None.

pub fn as_usize(self) -> usize

Return this unit as a usize, regardless of whether it is a byte value or an “end of input” sentinel. In the latter case, the underlying sentinel value given to Unit::eoi is returned.

pub fn is_byte(self, byte: u8) -> bool

Returns true if and only of this unit is a byte value equivalent to the byte given. This always returns false when this is an “end of input” sentinel.

pub fn is_eoi(self) -> bool

Returns true when this unit represents an “end of input” sentinel.

pub fn is_word_byte(self) -> bool

Returns true when this unit corresponds to an ASCII word byte.

This always returns false when this unit represents an “end of input” sentinel.

Trait Implementations

impl Clone for Unit

fn clone(&self) -> Unit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Unit

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

Formats the value using the given formatter.

impl Ord for Unit

fn cmp(&self, other: &Unit) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Unit

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

fn partial_cmp(&self, other: &Unit) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Unit

impl Eq for Unit

impl StructuralPartialEq for Unit