impl Cache

fn new(re: &BoundedBacktracker) -> Cache

Create a new BoundedBacktracker cache.

A potentially more convenient routine to create a cache is BoundedBacktracker::create_cache, as it does not require also importing the Cache type.

If you want to reuse the returned Cache with some other BoundedBacktracker, then you must call Cache::reset with the desired BoundedBacktracker.

fn reset(self: &mut Self, re: &BoundedBacktracker)

Reset this cache such that it can be used for searching with different BoundedBacktracker.

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

Example

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

# if cfg!(miri) { return Ok(()); } // miri takes too long
use regex_automata::{
    nfa::thompson::backtrack::BoundedBacktracker,
    Match,
};

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

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

// 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 BoundedBacktracker 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(Ok(Match::must(0, 0..3))),
    re2.try_find_iter(&mut cache, "☃").next(),
);

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

fn memory_usage(self: &Self) -> usize

Returns the heap memory usage, in bytes, of this cache.

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>