Enum magic_regexp::Input

pub enum Input<'a> {
    OneOrMore(Type<'a>),
    Exactly(Type<'a>),
    Maybe(Type<'a>),
    Times(Type<'a>, usize),
}

This is a regex input that can be used to match a single character or a group of characters. Can be used to create a regex that matches a single character or a group of characters. For example, Input::Exactly(Type::Digit) will match a single digit.

Example

use magic_regexp::{create_reg_exp, Input, Type};

let regex = create_reg_exp(Input::Exactly(Type::Digit)).unwrap();
assert!(regex.is_match("1"));
assert!(!regex.is_match("12"));
assert!(regex.is_match("1 2"));

Example

use magic_regexp::{create_reg_exp, Input, Type};

let regex = create_reg_exp(Input::OneOrMore(Type::Digit)).unwrap();
assert!(regex.is_match("1"));
assert!(regex.is_match("12"));
assert!(regex.is_match("1 2"));

Example

use magic_regexp::{create_reg_exp, Input, Type};

let regex = create_reg_exp(Input::Maybe(Type::Digit)).unwrap();
assert!(regex.is_match("1"));
assert!(regex.is_match(""));
assert!(regex.is_match("12"));
assert!(regex.is_match("a"));
assert!(regex.is_match("1 2"));

Variants

OneOrMore(Type<'a>)

Exactly(Type<'a>)

Maybe(Type<'a>)

Times(Type<'a>, usize)

Implementations

impl<'a> Input<'a>

pub fn grouped_as(&self, name: &str) -> Regex

This defines the entire input so far as a named capture group.

Example

use magic_regexp::{create_reg_exp, Condition, Exactly, Digit, LetterLowercase, OneOrMore};

let regex = create_reg_exp(OneOrMore(Digit).grouped_as("digits")).unwrap();
assert_eq!(&regex.captures("1").unwrap()["digits"], "1");

pub fn as(&self, name: &str) -> Regex

This defines the entire input so far as a named capture group. This is an alias for grouped_as.

pub fn grouped(&self) -> Regex

This defines the entire input so far as an anonymous group.

Example

use magic_regexp::{create_reg_exp, Condition, Exactly, Digit, LetterLowercase, OneOrMore, Type, Char, Whitespace, Maybe, Options};
use regex::Regex;

let regex = create_reg_exp(OneOrMore(Digit).grouped()
    .and(Exactly(Whitespace))
    .and(OneOrMore(Char).or(Exactly(Whitespace)).optionally())
    .and(OneOrMore(Digit).grouped())
).unwrap();
assert_eq!(&regex.captures("1 5").unwrap()[1], "1");
assert_eq!(&regex.captures("134 23").unwrap()[1], "134");
// The folloing example is not really useful, because it shows only the first match.
// The second match is not captured. See the next example for a more useful example.
assert_eq!(&regex.captures("this is the 134 test 213").unwrap()[1], "134");
// This is a bit more complex, because we are using anonymous groups in regex.
let cap = &regex
    .find_iter("multiple numbers 134 2123")
    .filter_map(|digits| digits.as_str().parse().ok())
    .collect::<Vec<String>>()
    .join(" ");
let expected = ["134", "2123"].join(" ");
assert_eq!(cap, &expected);

Trait Implementations

impl<'a> AsRegex for Input<'a>

fn as_regex(&self) -> Result<Regex>

Returns the regex, which represents the wanted statement.

impl<'a> Condition for Input<'a>

Returns a Regex, which chains the 2 given regexes with an and operator.

Example

use magic_regexp::{create_reg_exp, Condition, Exactly, Digit, LetterLowercase};

let regex = create_reg_exp(Exactly(Digit).or(Exactly(LetterLowercase))).unwrap();
assert!(regex.is_match("1"));
assert!(regex.is_match("a"));
assert!(!regex.is_match("A"));
assert!(!regex.is_match("12"));
assert!(!regex.is_match("1a"));
assert!(regex.is_match("1 a"));

fn and(self, other: impl AsRegex) -> Regex

Returns the regex, which chains the two given statements with an and condition.

fn or(self, other: impl AsRegex) -> Regex

Returns the regex, which chains the two given statements with an or condition.

fn optionally(self) -> Regex

Returns the regex, which sets the given statement to optional.

impl<'a> Display for Input<'a>

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

Formats the value using the given formatter.