Struct regex_automata::hybrid::regex::Cache
source · pub struct Cache { /* private fields */ }
Expand description
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§
source§impl Cache
impl Cache
sourcepub fn new(re: &Regex) -> 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
.
sourcepub fn reset(&mut self, re: &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, "☃"),
);
sourcepub fn forward_mut(&mut self) -> &mut 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
.
sourcepub fn reverse_mut(&mut self) -> &mut Cache
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
.
sourcepub fn as_parts(&self) -> (&Cache, &Cache)
pub fn as_parts(&self) -> (&Cache, &Cache)
Return references to the forward and reverse caches, respectively.
sourcepub fn as_parts_mut(&mut self) -> (&mut Cache, &mut Cache)
pub fn as_parts_mut(&mut self) -> (&mut Cache, &mut Cache)
Return mutable references to the forward and reverse caches, respectively.
sourcepub fn memory_usage(&self) -> usize
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>()
.