Trait happylock::Lockable

pub unsafe trait Lockable<'a> {
    type Output;

    // Required methods
    fn get_ptrs(&self) -> Vec<usize>;
    unsafe fn lock(&'a self) -> Self::Output;
    unsafe fn try_lock(&'a self) -> Option<Self::Output>;
}

A type that may be locked and unlocked

Safety

A deadlock must never occur. The unlock method must correctly unlock the data. The get_ptrs method must be implemented correctly. The Output must be unlocked when it is dropped.

Required Associated Types

type Output

The output of the lock

Required Methods

fn get_ptrs(&self) -> Vec<usize>

Returns a list of all pointers to locks. This is used to ensure that the same lock isn’t included twice

unsafe fn lock(&'a self) -> Self::Output

Blocks until the lock is acquired

Safety

It is undefined behavior to:

• Use this without ownership or mutable access to the ThreadKey, which should last as long as the return value is alive.
• Call this on multiple locks without unlocking first.

unsafe fn try_lock(&'a self) -> Option<Self::Output>

Attempt to lock without blocking.

Returns Some if successful, None otherwise.

Safety

It is undefined behavior to use this without ownership or mutable access to the ThreadKey, which should last as long as the return value is alive.

Implementations on Foreign Types

impl<'a, A: Lockable<'a>> Lockable<'a> for (A,)

type Output = (<A as Lockable<'a>>::Output,)

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, A: Lockable<'a>, B: Lockable<'a>> Lockable<'a> for (A, B)

type Output = (<A as Lockable<'a>>::Output, <B as Lockable<'a>>::Output)

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, A: Lockable<'a>, B: Lockable<'a>, C: Lockable<'a>> Lockable<'a> for (A, B, C)

type Output = (<A as Lockable<'a>>::Output, <B as Lockable<'a>>::Output, <C as Lockable<'a>>::Output)

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, A: Lockable<'a>, B: Lockable<'a>, C: Lockable<'a>, D: Lockable<'a>> Lockable<'a> for (A, B, C, D)

type Output = (<A as Lockable<'a>>::Output, <B as Lockable<'a>>::Output, <C as Lockable<'a>>::Output, <D as Lockable<'a>>::Output)

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, A: Lockable<'a>, B: Lockable<'a>, C: Lockable<'a>, D: Lockable<'a>, E: Lockable<'a>> Lockable<'a> for (A, B, C, D, E)

type Output = (<A as Lockable<'a>>::Output, <B as Lockable<'a>>::Output, <C as Lockable<'a>>::Output, <D as Lockable<'a>>::Output, <E as Lockable<'a>>::Output)

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, A: Lockable<'a>, B: Lockable<'a>, C: Lockable<'a>, D: Lockable<'a>, E: Lockable<'a>, F: Lockable<'a>> Lockable<'a> for (A, B, C, D, E, F)

type Output = (<A as Lockable<'a>>::Output, <B as Lockable<'a>>::Output, <C as Lockable<'a>>::Output, <D as Lockable<'a>>::Output, <E as Lockable<'a>>::Output, <F as Lockable<'a>>::Output)

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, T: Lockable<'a>> Lockable<'a> for &T

type Output = <T as Lockable<'a>>::Output

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, T: Lockable<'a>> Lockable<'a> for &mut T

type Output = <T as Lockable<'a>>::Output

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, T: Lockable<'a>> Lockable<'a> for Box<[T]>

type Output = Box<[<T as Lockable<'a>>::Output]>

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, T: Lockable<'a>> Lockable<'a> for Vec<T>

type Output = Vec<<T as Lockable<'a>>::Output>

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

impl<'a, T: Lockable<'a>, const N: usize> Lockable<'a> for [T; N]

type Output = [<T as Lockable<'a>>::Output; N]

fn get_ptrs(&self) -> Vec<usize>

unsafe fn lock(&'a self) -> Self::Output

unsafe fn try_lock(&'a self) -> Option<Self::Output>

Implementors

impl<'a, T: 'a, R: RawMutex + 'a> Lockable<'a> for Mutex<T, R>

type Output = MutexRef<'a, T, R>

impl<'a, T: 'a, R: RawRwLock + 'a> Lockable<'a> for ReadLock<'a, T, R>

type Output = RwLockReadRef<'a, T, R>

impl<'a, T: 'a, R: RawRwLock + 'a> Lockable<'a> for RwLock<T, R>

type Output = RwLockWriteRef<'a, T, R>

impl<'a, T: 'a, R: RawRwLock + 'a> Lockable<'a> for WriteLock<'a, T, R>

type Output = RwLockWriteRef<'a, T, R>