Struct safe_regex::Matcher0

pub struct Matcher0<F> where
    F: Fn(&[u8]) -> Option<()>,  { /* fields omitted */ }

A compiled regular expression with no capturing groups.

This is a zero-length type. The regex! macro generates a Rust type that implements the regular expression. This struct holds that type.

Implementations

impl<F> Matcher0<F> where
    F: Fn(&[u8]) -> Option<()>, 

#[must_use]pub fn match_all(&self, data: &[u8]) -> Option<()>

Executes the regular expression against the byte string data.

Returns Some if the expression matched all of the bytes in data.

This is a whole-string match. For sub-string search, put .* at the beginning and end of the regex.

Returns None if the expression did not match data.

Example

use safe_regex::{regex, IsMatch, Matcher2};
let matcher: Matcher2<_> = regex!(br"([abc])([0-9]*)");
let (prefix, digits) = matcher.match_all(b"a42").unwrap();
assert_eq!(b"a", prefix.unwrap());
assert_eq!(b"42", digits.unwrap());

#[must_use]pub fn new(f: F) -> Self

This is used internally by the regex! macro. This is used internally by the regex! macro.

Trait Implementations

impl<F> IsMatch for Matcher0<F> where
    F: Fn(&[u8]) -> Option<()>, 

#[must_use]fn is_match(&self, data: &[u8]) -> bool

Returns true if data matches the regular expression, otherwise returns false.