Struct regex_automata::hybrid::regex::Cache

pub struct Cache { /* private fields */ }

A cache represents a partially computed forward and reverse DFA.

A cache is the key component that differentiates a classical DFA and a hybrid NFA/DFA (also called a “lazy DFA”). Where a classical DFA builds a complete transition table that can handle all possible inputs, a hybrid NFA/DFA starts with an empty transition table and builds only the parts required during search. The parts that are built are stored in a cache. For this reason, a cache is a required parameter for nearly every operation on a Regex.

Caches can be created from their corresponding Regex via Regex::create_cache. A cache can only be used with either the Regex that created it, or the Regex that was most recently used to reset it with Cache::reset. Using a cache with any other Regex may result in panics or incorrect results.

Implementations

impl Cache

pub fn new(re: &Regex) -> Cache

Create a new cache for the given Regex.

The cache returned should only be used for searches for the given Regex. If you want to reuse the cache for another Regex, then you must call Cache::reset with that Regex.

pub fn reset(&mut self, re: &Regex)

Reset this cache such that it can be used for searching with the given Regex (and only that Regex).

A cache reset permits reusing memory already allocated in this cache with a different Regex.

Resetting a cache sets its “clear count” to 0. This is relevant if the Regex has been configured to “give up” after it has cleared the cache a certain number of times.

Example

This shows how to re-purpose a cache for use with a different Regex.

use regex_automata::{hybrid::regex::Regex, Match};

let re1 = Regex::new(r"\w")?;
let re2 = Regex::new(r"\W")?;

let mut cache = re1.create_cache();
assert_eq!(
    Some(Match::must(0, 0..2)),
    re1.find(&mut cache, "Δ"),
);

// Using 'cache' with re2 is not allowed. It may result in panics or
// incorrect results. In order to re-purpose the cache, we must reset
// it with the Regex we'd like to use it with.
//
// Similarly, after this reset, using the cache with 're1' is also not
// allowed.
cache.reset(&re2);
assert_eq!(
    Some(Match::must(0, 0..3)),
    re2.find(&mut cache, "☃"),
);

pub fn forward(&mut self) -> &Cache

Return a reference to the forward cache.

pub fn reverse(&mut self) -> &Cache

Return a reference to the reverse cache.

pub fn forward_mut(&mut self) -> &mut Cache

Return a mutable reference to the forward cache.

If you need mutable references to both the forward and reverse caches, then use Cache::as_parts_mut.

pub fn reverse_mut(&mut self) -> &mut Cache

Return a mutable reference to the reverse cache.

If you need mutable references to both the forward and reverse caches, then use Cache::as_parts_mut.

pub fn as_parts(&self) -> (&Cache, &Cache)

Return references to the forward and reverse caches, respectively.

pub fn as_parts_mut(&mut self) -> (&mut Cache, &mut Cache)

Return mutable references to the forward and reverse caches, respectively.

pub fn memory_usage(&self) -> usize

Returns the heap memory usage, in bytes, as a sum of the forward and reverse lazy DFA caches.

This does not include the stack size used up by this cache. To compute that, use std::mem::size_of::<Cache>().

Trait Implementations

impl Clone for Cache

fn clone(&self) -> Cache

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Cache

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.