Function regaexec

pub fn regaexec<'a>(
    compiled_reg: &Regex,
    string: &'a str,
    params: &RegApproxParams,
    nmatches: usize,
    flags: RegexecFlags,
) -> Result<RegApproxMatchStr<'a>>

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

This is a thin wrapper around Regex::regaexec.

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

Arguments

• compiled_reg: the compiled Regex object.
• string: string 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, Results will be returned, containing either errors or substrings of the matches. Errors may be returned due to decoding problems, such as split codepoints.

Errors

If an error is encountered during matching, it returns a RegexError. Match results may also return errors, if decoding into UTF-8 was unsuccessful for whatever reason.

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, regaexec};

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(
    &compiled_reg,      // Compiled regex
    "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.as_ref().unwrap()),
        None => println!("Match {i}: <None>"),
    }
}