Struct `Cache`

struct Cache { ... }

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`

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.

fn reset(self: &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.

# if cfg!(miri) { return Ok(()); } // miri takes too long
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, "☃"),
);

# Ok::<(), Box<dyn std::error::Error>>(())

fn forward(self: &mut Self) -> &Cache

Return a reference to the forward cache.

fn reverse(self: &mut Self) -> &Cache

Return a reference to the reverse cache.

fn forward_mut(self: &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.

fn reverse_mut(self: &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.

fn as_parts(self: &Self) -> (&Cache, &Cache)

Return references to the forward and reverse caches, respectively.

fn as_parts_mut(self: &mut Self) -> (&mut Cache, &mut Cache)

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

fn memory_usage(self: &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>().

`impl Clone for Cache`

fn clone(self: &Self) -> Cache

`impl Debug for Cache`

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

`impl Freeze for Cache`

`impl RefUnwindSafe for Cache`

`impl Send for Cache`

`impl Sync for Cache`

`impl Unpin for Cache`

`impl UnsafeUnpin for Cache`

`impl UnwindSafe for Cache`

`impl<T> Any for Cache`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Cache`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Cache`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Cache`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Cache`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Cache`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Cache`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Cache`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Cache`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>