Struct Guard

pub struct Guard<'a, T: ?Sized, B: Backend> { /* private fields */ }

A lock guard.

Allows mutual exclusion primitives that implement the Backend trait to automatically unlock when a guard goes out of scope. It also provides a safe and convenient way to access the data protected by the lock.

Implementations

impl<'a, T: ?Sized, B: Backend> Guard<'a, T, B>

pub fn lock_ref(&self) -> &'a Lock<T, B>

Returns the lock that this guard originates from.

Examples

The following example shows how to use Guard::lock_ref() to assert the corresponding lock is held.

fn assert_held<T, B: Backend>(guard: &Guard<'_, T, B>, lock: &Lock<T, B>) {
    // Address-equal means the same lock.
    assert!(core::ptr::eq(guard.lock_ref(), lock));
}

// Creates a new lock on the stack.
stack_pin_init!{
    let l = new_spinlock!(42)
}

let g = l.lock();

// `g` originates from `l`.
assert_held(&g, &l);

impl<'a, T: ?Sized, B: Backend> Guard<'a, T, B>

pub unsafe fn new(lock: &'a Lock<T, B>, state: B::GuardState) -> Self

Constructs a new immutable lock guard.

Safety

The caller must ensure that it owns the lock.

Trait Implementations

impl<T: ?Sized, B: Backend> Deref for Guard<'_, T, B>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: ?Sized, B: Backend> DerefMut for Guard<'_, T, B>

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

Mutably dereferences the value.

impl<T: ?Sized, B: Backend> Drop for Guard<'_, T, B>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Sync + ?Sized, B: Backend> Sync for Guard<'_, T, B>