Enum rec::Class

pub enum Class {
    Alpha,
    AlphaNum,
    Digit,
    Whitespace,
    Any,
    Start,
    End,
    Sign,
    NonZeroDigit,
    HexDigit,
}

An enumeration of predefined single character matches.

Variants

Alpha

Matches any alphabetic character.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::Alpha, Rec::from("[[:alpha:]]"));

AlphaNum

Matches any alphabetic or numerical digit character.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::AlphaNum, Rec::from("[[:alnum:]]"));

Digit

Matches any numerical digit character.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::Digit, Rec::from(r"\d"));

Whitespace

Matches any whitespace character.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::Whitespace, Rec::from(r"\s"));

Any

Matches any character other than a newline.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::Any, Rec::from("."));

Start

Matches with the start of the text.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::Start, Rec::from("^"));

End

Matches with the end of the text.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::End, Rec::from("$"));

Sign

Matches with the sign character of a number.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::Sign, Rec::from(r"[+\-]"));

NonZeroDigit

Matches with any digit that is not 0.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::NonZeroDigit, Rec::from(r"[1-9]"));

HexDigit

Matches with any hexidecimal digit.

Examples

use rec::{Class, prelude::*};

assert_eq!(Class::HexDigit, Rec::from("[[:xdigit:]]"));

Trait Implementations

impl Atom for Class

fn to_part(&self) -> String

Converts self to a String that contains everything inside the [] brackets.

impl Element for Class

fn to_regex(&self) -> String

Converts self to a regular expression compatible with regex.

fn is_atom(&self) -> bool

Returns if self is an Atom.

fn alternate(&self, other: &dyn Element) -> Rec

Creates a Rec consisting of the alternation of self and other.

fn concatenate(&self, other: &dyn Element) -> Rec

Creates a Rec consisting of the concatenation of self and other.

fn is_equal(&self, other: &dyn Element) -> bool

Returns if the regular expression of self is equal to that of other.

fn isolate(&self) -> String

Returns the regular expression of self such that it can be concatenated.

fn group(&self) -> String

Returns the regular expression of self as a single Atom.

impl<T: Element> PartialEq<T> for Class

fn eq(&self, other: &T) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Copy for Class

impl Clone for Class

fn clone(&self) -> Class

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Rhs: Element> Add<Rhs> for Class

type Output = Rec

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl Add<Class> for char

type Output = Rec

The resulting type after applying the + operator.

fn add(self, rhs: Class) -> Self::Output

use rec::{Class, prelude::*};

assert_eq!('a' + Class::Digit, Rec::from(r"a\d"));

impl<'_> Add<Class> for &'_ str

type Output = Rec

The resulting type after applying the + operator.

fn add(self, rhs: Class) -> Self::Output

use rec::{Class, prelude::*};

assert_eq!("hello" + Class::Digit, Rec::from(r"hello\d"));

impl BitOr<char> for Class

type Output = Ch

The resulting type after applying the | operator.

fn bitor(self, rhs: char) -> Self::Output

use rec::{Class, prelude::*};

assert_eq!(Class::Alpha | '0', Rec::from("[[:alpha:]0]"));

impl BitOr<Class> for Class

type Output = Ch

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

use rec::{Class, prelude::*};

assert_eq!(Class::Alpha | Class::Whitespace, Rec::from(r"[[:alpha:]\s]"));

use rec::{Class, prelude::*};

assert_eq!(Class::Alpha | Class::Digit, Rec::from("[[:alnum:]]"));

impl<'_> BitOr<&'_ str> for Class

type Output = Rec

The resulting type after applying the | operator.

fn bitor(self, rhs: &str) -> Self::Output

use rec::{Class, prelude::*};

assert_eq!(Class::Alpha | "12", Rec::from("[[:alpha:]]|12"));

impl BitOr<Rec> for Class

type Output = Rec

The resulting type after applying the | operator.

fn bitor(self, rhs: Rec) -> Self::Output

Performs the | operation.

impl Debug for Class

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

Formats the value using the given formatter.