Struct PrisonValueMut 

pub struct PrisonValueMut<'a, T> { /* private fields */ }

Struct representing a mutable reference to a value that has been allowed to leave the Prison temporarily, but remains guarded by a wrapper to prevent it from leaking or never unlocking

PrisonValueMut implements [Deref<Target = T>], [DerefMut<Target = T>], AsRef, AsMut, Borrow, and BorrowMut to allow transparent access to its underlying value

As long as the PrisonValueMut remains in scope, the element where it’s value resides in the Prison will remain marked as mutably referenced and unable to be referenced a second time. You can manually drop the PrisonValueMut out of scope by passing it as the first parameter to the function [PrisonValueMut::unguard(p_val_mut)]

You can obtain a PrisonValueMut by calling guard_mut() or guard_mut_idx() on a Prison

Example

let prison: Prison<u32> = Prison::new();
let key_0 = prison.insert(10)?;
let mut grd_0 = prison.guard_mut(key_0)?;
assert_eq!(*grd_0, 10);
*grd_0 = 20;
PrisonValueMut::unguard(grd_0);
prison.visit_ref(key_0, |val_0| {
    assert_eq!(*val_0, 20);
    Ok(())
});

Implementations

impl<'a, T> PrisonValueMut<'a, T>

pub fn unguard(_prison_val_mut: Self)

Manually end a PrisonValueMut value’s temporary guarded absence from the Prison

This method simply takes ownership of the PrisonValueMut and immediately lets it go out of scope, causing it’s drop() method to be called and clearing its mutable reference in the Prison

Example

let prison: Prison<u32> = Prison::new();
prison.insert(10)?;
let grd_0 = prison.guard_mut_idx(0)?;
// index 0 CANNOT be accessed here because it is being guarded outside the prison
assert!(prison.visit_ref_idx(0, |ref_0| Ok(())).is_err());
PrisonValueMut::unguard(grd_0);
// index 0 CAN be accessed here because it was returned to the prison
assert!(prison.visit_ref_idx(0, |ref_0| Ok(())).is_ok());

Trait Implementations

impl<'a, T> AsMut<T> for PrisonValueMut<'a, T>

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'a, T> AsRef<T> for PrisonValueMut<'a, T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a, T> Borrow<T> for PrisonValueMut<'a, T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<'a, T> BorrowMut<T> for PrisonValueMut<'a, T>

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

Mutably borrows from an owned value.

impl<'a, T> Deref for PrisonValueMut<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T> DerefMut for PrisonValueMut<'a, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T> Drop for PrisonValueMut<'a, T>

fn drop(&mut self)

Executes the destructor for this type.