Function regawexec

pub fn regawexec<'a>(
    compiled_reg: &Regex,
    string: &'a WideStr,
    params: &RegApproxParams,
    nmatches: usize,
    flags: RegexecFlags,
) -> Result<RegApproxMatchWideStr<'a>>

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

This is a thin wrapper around Regex::regawexec.

Non-matching subexpressions or patterns will return None in the results.

Arguments

• compiled_reg: the compiled Regex object.
• string: WideStr 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, a WideStr 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 string. This is because they are slices into string under the hood, for efficiency.

Examples

use tre_regex::{RegcompFlags, RegexecFlags, RegApproxParams, Regex, regawexec};
use widestring::widestr;

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_wide(widestr!("^(hello).*(world)$"), regcomp_flags)?;
let result = regawexec(
    &compiled_reg,              // Compiled regex
    widestr!("hello world"),    // String 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}: {}", substr.display()),
        None => println!("Match {i}: <None>"),
    }
}