Function tre_regex::regaexec_bytes

pub fn regaexec_bytes<'a>(
    compiled_reg: &Regex,
    data: &'a [u8],
    params: &RegApproxParams,
    nmatches: usize,
    flags: RegexecFlags
) -> Result<RegApproxMatchBytes<'a>>

Performs an approximate regex search on the passed bytes, returning nmatches results.

This is a thin wrapper around Regex::regaexec_bytes.

This function should only be used if you need to match raw bytes, or bytes which may not be UTF-8 compliant. Otherwise, regaexec is recommended instead.

Arguments

• compiled_reg: the compiled Regex object.
• data: u8 slice to match against compiled_reg
• params: see RegApproxParams
• nmatches: number of matches to return
• flags: RegexecFlags to pass to tre_regnexec.

Returns

If no error was found, a Vec of Options will be returned.

If a given match index is empty, The Option will be None. Otherwise, u8 slices will be returned.

Errors

If an error is encountered during matching, it returns a RegexError.

Caveats

Unless copied, the match results must live at least as long as data. This is because they are slices into data under the hood, for efficiency.

Examples

use tre_regex::{RegcompFlags, RegexecFlags, RegApproxParams, Regex, regaexec_bytes};

let regcomp_flags = RegcompFlags::new()
    .add(RegcompFlags::EXTENDED)
    .add(RegcompFlags::ICASE);
let regaexec_flags = RegexecFlags::new().add(RegexecFlags::NONE);
let regaexec_params = RegApproxParams::new()
    .cost_ins(1)
    .cost_del(1)
    .cost_subst(1)
    .max_cost(2)
    .max_del(2)
    .max_ins(2)
    .max_subst(2)
    .max_err(2);

let compiled_reg = Regex::new("^(hello).*(world)$", regcomp_flags)?;
let result = regaexec_bytes(
    &compiled_reg,      // Compiled regex
    b"hello world",     // Bytes to match against
    &regaexec_params,   // Matching parameters
    3,                  // Number of matches we want
    regaexec_flags      // Flags
)?;

for (i, matched) in result.get_matches().into_iter().enumerate() {
    match matched {
        Some(substr) => println!(
            "Match {i}: {}",
            std::str::from_utf8(substr).unwrap()
        ),
        None => println!("Match {i}: <None>"),
    }
}