Enum CheckPattern

pub enum CheckPattern<'a> {
    Empty(SourceSpan),
    Literal(Span<Cow<'a, str>>),
    Regex(RegexPattern<'a>),
    Match(Span<Vec<CheckPatternPart<'a>>>),
}

A check pattern is the part of a check line which must match in the check file somewhere

Variants

Empty(SourceSpan)

There is no content, we’re at the end of line

Literal(Span<Cow<'a, str>>)

The entire pattern is a single raw string

Regex(RegexPattern<'a>)

The entire pattern is a single regex string

Match(Span<Vec<CheckPatternPart<'a>>>)

The pattern is some mix of literal parts and match rules

Implementations

impl<'a> CheckPattern<'a>

pub fn is_empty(&self) -> bool

pub fn locate_variables(&self) -> impl Iterator<Item = SourceSpan> + '_

pub fn prefix(&self) -> Prefix<'a>

pub fn pop_prefix(&mut self) -> Prefix<'a>

pub fn is_literal(&self) -> bool

pub fn is_regex_compatible(&self) -> bool

pub fn compact(&mut self, interner: &StringInterner)

Compacts this pattern into fewer parts where possible

pub fn into_regex_pattern( self, interner: &StringInterner, ) -> Result<RegexPattern<'a>, Self>

Converts this pattern into a string which can be used as a regular expression, even if the pattern was not originally expressed as a regular expression.

Returns Err with the original pattern (potentially compacted), if the conversion is not possible. Otherwise, returns Ok with the built regular expression pattern.

Trait Implementations

impl<'a> Debug for CheckPattern<'a>

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

Formats the value using the given formatter.

impl<'a> From<Vec<CheckPatternPart<'a>>> for CheckPattern<'a>

fn from(parts: Vec<CheckPatternPart<'a>>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for CheckPattern<'a>

fn eq(&self, other: &Self) -> 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<'a> Spanned for CheckPattern<'a>

fn span(&self) -> SourceSpan

fn start(&self) -> usize

fn end(&self) -> usize

fn range(&self) -> Range<usize>