Struct sharded_slab::pool::RefMut [−][src]
pub struct RefMut<'a, T, C = DefaultConfig> where
T: Clear + Default,
C: Config, { /* fields omitted */ }
A guard that allows exclusive mutable access to an object in a pool.
While the guard exists, it indicates to the pool that the item the guard references is currently being accessed. If the item is removed from the pool while a guard exists, the removal will be deferred until the guard is dropped. The slot cannot be accessed by other threads while it is accessed mutably.
Implementations
impl<'a, T, C: Config> RefMut<'a, T, C> where
T: Clear + Default,
C: Config, [src]
impl<'a, T, C: Config> RefMut<'a, T, C> where
T: Clear + Default,
C: Config, [src]pub fn key(&self) -> usize[src]
Returns the key used to access the guard.
pub fn downgrade(self) -> Ref<'a, T, C>[src]
Downgrades the mutable guard to an immutable guard, allowing access to the pooled value from other threads.
Examples
let pool = Arc::new(Pool::<String>::new()); let mut guard_mut = pool.clone().create_owned().unwrap(); let key = guard_mut.key(); guard_mut.push_str("Hello"); // The pooled string is currently borrowed mutably, so other threads // may not access it. let pool2 = pool.clone(); thread::spawn(move || { assert!(pool2.get(key).is_none()) }).join().unwrap(); // Downgrade the guard to an immutable reference. let guard = guard_mut.downgrade(); // Now, other threads may also access the pooled value. let pool2 = pool.clone(); thread::spawn(move || { let guard = pool2.get(key) .expect("the item may now be referenced by other threads"); assert_eq!(guard, String::from("Hello")); }).join().unwrap(); // We can still access the value immutably through the downgraded guard. assert_eq!(guard, String::from("Hello"));