Enum ReadableRe

pub enum ReadableRe<'a> {
    Digit,
    Word,
    Whitespace,
    NonDigit,
    NonWord,
    NonWhitespace,
    Boundary,
    AsciiLetter,
    AsciiNonLetter,
    AsciiUppercase,
    AsciiNonUppercase,
    AsciiLowercase,
    AsciiNonLowercase,
    AsciiAlphanumeric,
    AsciiNonAlphanumeric,
    AsciiNumeric,
    AsciiNonNumeric,
    Hexadecimal,
    NonHexadecimal,
    Anything,
    Everything,
    SomethingGreedy,
    Something,
    AnyChar,
    Period,
    Caret,
    Dollar,
    Asterisk,
    PlusSign,
    MinusSign,
    QuestionMark,
    OpenBrace,
    CloseBrace,
    OpenBracket,
    CloseBracket,
    OpenParenthesis,
    CloseParenthesis,
    BackSlash,
    Pipe,
    Newline,
    Tab,
    Quote,
    DoubleQuote,
    Raw(&'a str),
    String(String),
    Concat(Concat<'a>),
    Escape(Escape<'a>),
    Group(Group<'a>),
    NamedGroup(NamedGroup<'a>),
    NonCaptureGroup(NonCaptureGroup<'a>),
    Optional(Optional<'a>),
    Either(Either<'a>),
    Exactly(Exactly<'a>),
    Ranged(Ranged<'a>),
    ZeroOrMore(ZeroOrMore<'a>),
    ZeroOrMoreLazy(ZeroOrMoreLazy<'a>),
    OneOrMore(OneOrMore<'a>),
    OneOrMoreLazy(OneOrMoreLazy<'a>),
    StartsWith(StartsWith<'a>),
    EndsWith(EndsWith<'a>),
    StartsAndEndsWith(StartsAndEndsWith<'a>),
    Chars(Chars),
    NotChars(NotChars),
}

Enum wrapper around regex expressions, it is a recursive version of regexes

Variants

Digit

digit match, "\d"

Word

word match, "\w"

Whitespace

whitespace match, "\s"

NonDigit

non digit match, "\D"

NonWord

non word match, "\W"

NonWhitespace

non whitespace match, "\S"

Boundary

boundary match, "\b"

AsciiLetter

ascii letters match, "[A-Za-z]"

AsciiNonLetter

ascii non letters match, "[^A-Za-z]"

AsciiUppercase

ascii uppercase letters match, "[A-Z]"

AsciiNonUppercase

ascii non uppercase letters match, "[^A-Z]"

AsciiLowercase

ascii lowercase letters match, "[a-z]"

AsciiNonLowercase

ascii non lowercase letters match, "[^a-z]"

AsciiAlphanumeric

ascii alphanumerics chars match, "[A-Za-z0-9]"

AsciiNonAlphanumeric

ascii non alphanumerics chars match, "[^A-Za-z0-9]"

AsciiNumeric

ascii numeric match, "[0-9]"

AsciiNonNumeric

ascii non numeric match, "[^0-9]"

Hexadecimal

hexadecimal match, "[0-9A-Fa-f]"

NonHexadecimal

non hexadecimal match, "[^0-9A-Fa-f]"

Anything

anything match, ".*?"

Everything

everything match, ".*"

SomethingGreedy

something match, greedy, ".+"

Something

something match, ".+?"

AnyChar

any char match, "."

Period

escaped period, "\."

Caret

escaped caret, "\^"

Dollar

escaped dollar, "\$"

Asterisk

escaped asterisk, "\*"

PlusSign

escaped plus sign, "\+"

MinusSign

escaped minus sign, "\-"

QuestionMark

escaped question mark, "\?"

OpenBrace

escaped open brace, "\{"

CloseBrace

escaped close brace, "\}"

OpenBracket

escaped open bracket, "\["

CloseBracket

escaped close bracket, "\]"

OpenParenthesis

escaped open parenthesis, "\("

CloseParenthesis

escaped close bracket, "\)"

BackSlash

escaped back slash, "\\"

Pipe

escaped pipe, "\|"

Newline

escaped new line, "\n"

Tab

escaped tab, "\t"

Quote

escaped quote, "\'"

DoubleQuote

escaped double quote, "\""

Raw(&'a str)

raw regex exp, "exp"

String(String)

raw regex exp (owned), "exp"

Concat(Concat<'a>)

concatenation of regex exp, "exp1exp2exp3", check solvers::Concat

Escape(Escape<'a>)

Special characters escape wrapper, check solvers::Escape

Group(Group<'a>)

Regex group, "(expr)", check solvers::Group

NamedGroup(NamedGroup<'a>)

named group match, "(?P<name>expr)", check solvers::NamedGroup

NonCaptureGroup(NonCaptureGroup<'a>)

non-capture group, "(?:expr)"

Optional(Optional<'a>)

optional match, "expr?", check solvers::Optional

Either(Either<'a>)

either match, "expr1|expr2|...", check solvers::Either

Exactly(Exactly<'a>)

exact number (n) of occurrences match, "expr{n}", check solvers::Exactly

Ranged(Ranged<'a>)

variance number (min, max) of occurrences match, "expr{min, max}", check solvers::Ranged

ZeroOrMore(ZeroOrMore<'a>)

zero or more occurrences match, "expr*", check solvers::ZeroOrMore

ZeroOrMoreLazy(ZeroOrMoreLazy<'a>)

zero or more occurrences, lazy match, "expr*?", , check solvers::ZeroOrMoreLazy

OneOrMore(OneOrMore<'a>)

one or more occurrences match, "expr+", check solvers::OneOrMore

OneOrMoreLazy(OneOrMoreLazy<'a>)

one or more occurrences, lazy match, "expr+?", , check solvers::OneOrMoreLazy

StartsWith(StartsWith<'a>)

match start, "^expr", check solvers::StartsWith

EndsWith(EndsWith<'a>)

match end, "expr$", check solvers::EndsWith

StartsAndEndsWith(StartsAndEndsWith<'a>)

match start and end, "^expr$", check solvers::StartsAndEndsWith

Chars(Chars)

match characters, "[chars]", check solvers::Chars

NotChars(NotChars)

exclude match characters, "[^chars]", check solvers::NotChars

Implementations

impl<'a> ReadableRe<'a>

pub fn compile(&self) -> Result<Regex, Error>

Trait Implementations

impl<'a> Add for ReadableRe<'a>

type Output = ReadableRe<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Clone for ReadableRe<'a>

fn clone(&self) -> ReadableRe<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Display for ReadableRe<'_>

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for ReadableRe<'a>

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl<'a> From<String> for ReadableRe<'a>

fn from(s: String) -> Self

Converts to this type from the input type.

impl<'a> FromIterator<ReadableRe<'a>> for Concat<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for Either<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for EndsWith<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for Escape<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for Group<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for NonCaptureGroup<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for OneOrMore<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for OneOrMoreLazy<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for Optional<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for StartsAndEndsWith<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for StartsWith<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for ZeroOrMore<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<ReadableRe<'a>> for ZeroOrMoreLazy<'a>

fn from_iter<T: IntoIterator<Item = ReadableRe<'a>>>(iter: T) -> Self

Creates a value from an iterator.