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

source

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.

source

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, "☃"),
);
source

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

Return a reference to the forward cache.

source

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

Return a reference to the reverse cache.

source

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.

source

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.

source

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

Return references to the forward and reverse caches, respectively.

source

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

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

source

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§

source§

impl Clone for Cache

source§

fn clone(&self) -> Cache

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Cache

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

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> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

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

Performs the conversion.