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>()
.
Trait Implementations§
Auto Trait Implementations§
impl Freeze for Cache
impl RefUnwindSafe for Cache
impl Send for Cache
impl Sync for Cache
impl Unpin for Cache
impl UnwindSafe for Cache
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)