Struct PrisonValueRef

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

Struct representing an immutable 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

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

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

You can obtain a PrisonValueRef by calling guard_ref() or guard_ref_idx() on a Prison

Example

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

Implementations

impl<'a, T> PrisonValueRef<'a, T>

pub fn unguard(_prison_val_ref: Self)

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

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

Example

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

Trait Implementations

impl<'a, T> AsRef<T> for PrisonValueRef<'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 PrisonValueRef<'a, T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

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

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

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

fn drop(&mut self)

Executes the destructor for this type.