Struct concurrency_traits::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,
    M: RawAsyncMutex + 'a, 

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

The guard for this async mutex

type LockFuture = Pin<Box<dyn Future<Output = Self::AsyncGuard> + 'a>>

The future that the AsyncMutex::lock_async function returns

fn lock_async(&'a self) -> Self::LockFuture

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

impl<'a, T, M> AsyncMutexSized<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawAsyncMutex + 'a, 

fn lock_async_func<F>(
    &'a self,
    func: impl FnOnce(&mut Self::Item) -> F + 'a
) -> Pin<Box<dyn Future<Output = <F as Future>::Output> + 'a>> where
    F: Future, 

Locks the mutex and runs func on it asynchronously

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

type LockTimeoutFuture = Pin<Box<dyn Future<Output = Option<Self::AsyncGuard>> + 'a>>

The future returned by lock_timeout_async

fn lock_timeout_async(&'a self, timeout: Duration) -> Self::LockTimeoutFuture

Locks the mutex asynchronously with a timeout.

impl<'a, T, M> AsyncTimeoutMutexSized<'a> for CustomMutex<T, M> where
    T: 'a,
    M: RawAsyncTimeoutMutex + 'a, 

fn lock_timeout_async_func<F>(
    &'a self,
    timeout: Duration,
    func: impl FnOnce(Option<&mut Self::Item>) -> F + 'a
) -> Pin<Box<dyn Future<Output = <F as Future>::Output> + 'a>> where
    F: Future, 

Locks the mutex with a timeout and runs a function on the result asynchronously

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<T, M> Sync for CustomMutex<T, M> where
    T: Send,
    M: Sync, 

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.