Struct concurrency_traits::mutex::CustomMutex

pub struct CustomMutex<T, M: ?Sized> { /* fields omitted */ }

A Mutex based on a given RawTryMutex

Implementations

impl<T, M> CustomMutex<T, M>

pub const fn from_raw(raw_mutex: M, data: T) -> Self

Creates a new CustomMutex with a RawMutex

pub fn new(data: T) -> Self where
    M: Default, 

Creates a new mutex with a default raw

Trait Implementations

impl<'a, T, M> AsyncMutex<'a> for CustomMutex<T, M> where
    T: 'a + Send,
    M: RawAsyncMutex + 'a + Send + Sync, 

fn lock_async<'async_trait>(
    &'a self
) -> Pin<Box<dyn Future<Output = Self::Guard> + Send + 'async_trait>> where
    'a: 'async_trait,
    Self: 'async_trait, 

Locks the mutex asynchronously, returning a future with the guard.

impl<'a, T, M> AsyncTimeoutMutex<'a> for CustomMutex<T, M> where
    T: 'a + Send,
    M: RawAsyncTimeoutMutex + 'a + Send + Sync, 

fn lock_timeout_async<'async_trait>(
    &'a self,
    timeout: Duration
) -> Pin<Box<dyn Future<Output = Option<Self::Guard>> + Send + 'async_trait>> where
    'a: 'async_trait,
    Self: 'async_trait, 

Locks the mutex asynchronously with a timeout.

impl<T: Debug, M: Debug + ?Sized> Debug for CustomMutex<T, M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, M> Default for CustomMutex<T, M> where
    T: Default,
    M: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<T, M> From<T> for CustomMutex<T, M> where
    M: Default, 

fn from(from: T) -> Self

Performs the conversion.

impl<'a, T, M> Mutex<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawMutex + 'a, 

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

Locks the mutex, blocking until successful

impl<'a, T, M> MutexSized<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawMutex + 'a, 

fn lock_func<O>(&'a self, func: impl FnOnce(&mut Self::Item) -> O) -> O

Runs the function on the value in the mutex.

impl<'a, T, M> TimeoutMutex<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawTimeoutMutex + 'a, 

fn lock_timeout(&'a self, timeout: Duration) -> Option<Self::Guard>

Locks the mutex blocking for timeout or until locked

impl<'a, T, M> TimeoutMutexSized<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawTimeoutMutex + 'a, 

fn lock_timeout_func<O>(
    &'a self,
    timeout: Duration,
    func: impl FnOnce(Option<&mut Self::Item>) -> O
) -> O

Attempts to lock the mutex before timeout has passed and runs func on the result

impl<'a, T, M> TryMutex<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawTryMutex + 'a, 

type Item = T

The item stored in the mutex

type Guard = CustomMutexGuard<'a, T, M>

The guard for the mutex

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

Tries to lock the mutex, returning None if not possible.

impl<'a, T, M> TryMutexSized<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawTryMutex + 'a, 

fn try_lock_func<O>(
    &'a self,
    func: impl FnOnce(Option<&mut Self::Item>) -> O
) -> O

Runs the function the value in the mutex if available immediately.

impl<T, M> Sync for CustomMutex<T, M> where
    T: Send,
    M: Sync,