[−][src]Struct regex_cache::RegexCache
An LRU cache for regular expressions.
Implementations
impl RegexCache
[src]
pub fn new(capacity: usize) -> RegexCache
[src]
Create a new LRU cache with the given size limit.
pub fn save(&mut self, re: Regex) -> &Regex
[src]
Save the given regular expression in the cache.
Example
let mut cache = RegexCache::new(100); let re = Regex::new(r"^\d+$").unwrap(); // By saving the previously created regular expression further calls to // `compile` won't actually compile the regular expression. cache.save(re); assert!(cache.compile(r"^\d+$").unwrap().is_match("1234")); assert!(!cache.compile(r"^\d+$").unwrap().is_match("abcd"));
pub fn compile(&mut self, source: &str) -> Result<&Regex, Error>
[src]
Create a new regular expression in the cache.
Example
let mut cache = RegexCache::new(100); assert!(cache.compile(r"^\d+$").unwrap().is_match("1234")); assert!(!cache.compile(r"^\d+$").unwrap().is_match("abcd"));
pub fn configure<F>(&mut self, source: &str, f: F) -> Result<&Regex, Error> where
F: FnOnce(&mut RegexBuilder) -> &mut RegexBuilder,
[src]
F: FnOnce(&mut RegexBuilder) -> &mut RegexBuilder,
Configure a new regular expression.
Example
let mut cache = RegexCache::new(100); assert!(cache.configure(r"abc", |b| b.case_insensitive(true)).unwrap() .is_match("ABC")); assert!(!cache.configure(r"abc", |b| b.case_insensitive(true)).unwrap() .is_match("123"));
Methods from Deref<Target = LruCache<String, Regex>>
pub fn contains_key<Q>(&mut self, key: &Q) -> bool where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
[src]
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
Checks if the map contains the given key.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(1); cache.insert(1, "a"); assert_eq!(cache.contains_key(&1), true);
pub fn insert(&mut self, k: K, v: V) -> Option<V>
[src]
Inserts a key-value pair into the cache. If the key already existed, the old value is returned.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(2); cache.insert(1, "a"); cache.insert(2, "b"); assert_eq!(cache.get_mut(&1), Some(&mut "a")); assert_eq!(cache.get_mut(&2), Some(&mut "b"));
pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
[src]
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
Returns a mutable reference to the value corresponding to the given key in the cache, if any.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(2); cache.insert(1, "a"); cache.insert(2, "b"); cache.insert(2, "c"); cache.insert(3, "d"); assert_eq!(cache.get_mut(&1), None); assert_eq!(cache.get_mut(&2), Some(&mut "c"));
pub fn remove<Q>(&mut self, k: &Q) -> Option<V> where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
[src]
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
Removes the given key from the cache and returns its corresponding value.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(2); cache.insert(2, "a"); assert_eq!(cache.remove(&1), None); assert_eq!(cache.remove(&2), Some("a")); assert_eq!(cache.remove(&2), None); assert_eq!(cache.len(), 0);
pub fn capacity(&self) -> usize
[src]
Returns the maximum number of key-value pairs the cache can hold.
Examples
use lru_cache::LruCache; let mut cache: LruCache<i32, &str> = LruCache::new(2); assert_eq!(cache.capacity(), 2);
pub fn set_capacity(&mut self, capacity: usize)
[src]
Sets the number of key-value pairs the cache can hold. Removes least-recently-used key-value pairs if necessary.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(2); cache.insert(1, "a"); cache.insert(2, "b"); cache.insert(3, "c"); assert_eq!(cache.get_mut(&1), None); assert_eq!(cache.get_mut(&2), Some(&mut "b")); assert_eq!(cache.get_mut(&3), Some(&mut "c")); cache.set_capacity(3); cache.insert(1, "a"); cache.insert(2, "b"); assert_eq!(cache.get_mut(&1), Some(&mut "a")); assert_eq!(cache.get_mut(&2), Some(&mut "b")); assert_eq!(cache.get_mut(&3), Some(&mut "c")); cache.set_capacity(1); assert_eq!(cache.get_mut(&1), None); assert_eq!(cache.get_mut(&2), None); assert_eq!(cache.get_mut(&3), Some(&mut "c"));
pub fn remove_lru(&mut self) -> Option<(K, V)>
[src]
Removes and returns the least recently used key-value pair as a tuple.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(2); cache.insert(1, "a"); cache.insert(2, "b"); assert_eq!(cache.remove_lru(), Some((1, "a"))); assert_eq!(cache.len(), 1);
pub fn len(&self) -> usize
[src]
Returns the number of key-value pairs in the cache.
pub fn is_empty(&self) -> bool
[src]
Returns true
if the cache contains no key-value pairs.
pub fn clear(&mut self)
[src]
Removes all key-value pairs from the cache.
pub fn iter(&self) -> Iter<'_, K, V>
[src]
Returns an iterator over the cache's key-value pairs in least- to most-recently-used order.
Accessing the cache through the iterator does not affect the cache's LRU state.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(2); cache.insert(1, 10); cache.insert(2, 20); cache.insert(3, 30); let kvs: Vec<_> = cache.iter().collect(); assert_eq!(kvs, [(&2, &20), (&3, &30)]);
pub fn iter_mut(&mut self) -> IterMut<'_, K, V>
[src]
Returns an iterator over the cache's key-value pairs in least- to most-recently-used order, with mutable references to the values.
Accessing the cache through the iterator does not affect the cache's LRU state.
Examples
use lru_cache::LruCache; let mut cache = LruCache::new(2); cache.insert(1, 10); cache.insert(2, 20); cache.insert(3, 30); let mut n = 2; for (k, v) in cache.iter_mut() { assert_eq!(*k, n); assert_eq!(*v, n * 10); *v *= 10; n += 1; } assert_eq!(n, 4); assert_eq!(cache.get_mut(&2), Some(&mut 200)); assert_eq!(cache.get_mut(&3), Some(&mut 300));
Trait Implementations
impl Clone for RegexCache
[src]
fn clone(&self) -> RegexCache
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for RegexCache
[src]
impl Deref for RegexCache
[src]
type Target = LruCache<String, Regex>
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
impl DerefMut for RegexCache
[src]
Auto Trait Implementations
impl !RefUnwindSafe for RegexCache
impl Send for RegexCache
impl Sync for RegexCache
impl Unpin for RegexCache
impl !UnwindSafe for RegexCache
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,