Struct safe_regex::Matcher3

pub struct Matcher3<F> where
    F: Fn(&[u8]) -> Option<[Range<usize>; 3]>,  { /* fields omitted */ }

A compiled regular expression with 3 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> Matcher3<F> where
    F: Fn(&[u8]) -> Option<[Range<usize>; 3]>, 

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

This is used internally by the regex! macro.

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

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

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

Example

use safe_regex::{regex, Matcher0};
let matcher: Matcher0<_> = regex!(br"[abc][0-9]*");
assert!(matcher.is_match(b"a42"));
assert!(!matcher.is_match(b"X"));

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

Executes the regular expression against the byte string data.

Returns Some((Range<u32>,Range<u32>,...)) if the expression matched all of the bytes in data. The tuple fields are ranges of bytes in data that matched capturing groups in the expression. A capturing group that matches no bytes will produce as a zero-length range.

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, Matcher3};
let matcher: Matcher3<_> = regex!(br"([abc])([0-9]*)(suffix)?");
let (prefix, digits, suffix) = matcher.match_ranges(b"a42").unwrap();
assert_eq!(0..1_usize, prefix);
assert_eq!(1..3_usize, digits);
assert_eq!(0..0_usize, suffix);

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

Executes the regular expression against the byte string data.

Returns Some((&[u8],&[u8],...)) if the expression matched all of the bytes in data. The tuple fields are slices of data that matched capturing groups in the expression.

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, Matcher3};
let matcher: Matcher3<_> = regex!(br"([abc])([0-9]*)(suffix)?");
let (prefix, digits, suffix) = matcher.match_slices(b"a42").unwrap();
assert_eq!(b"a", prefix);
assert_eq!(b"42", digits);
assert!(suffix.is_empty());

Trait Implementations

impl<F: Fn(&[u8]) -> Option<[Range<usize>; 3]>> IsMatch for Matcher3<F>

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

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