Struct concurrency_traits::rw_lock::CustomRwLock

pub struct CustomRwLock<T, R> { /* fields omitted */ }

A custom rw lock that can be built from any RawTryRwLock variant

Implementations

impl<T, R> CustomRwLock<T, R>

pub fn from_raw(raw_lock: R, data: T) -> Self

Creates a lock from a RawTryRwLock variant

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

Creates a lock using thr RawTryRwLock variant’s default implementation

Trait Implementations

impl<'a, T, R> AsyncRwLock<'a> for CustomRwLock<T, R> where
    T: 'a + Send + Sync,
    R: RawAsyncRwLock + 'a + Send + Sync, 

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

Reads the lock asynchronously, giving a future that will contain the read lock

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

Writes to the lock asynchronously, giving a future that will contain the write lock

impl<'a, T, R> AsyncTimeoutRwLock<'a> for CustomRwLock<T, R> where
    T: 'a + Send + Sync,
    R: RawAsyncTimeoutRwLock + 'a + Send + Sync, 

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

Reads from the lock with a timeout asynchronously

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

Writes to the lock with a timeout asynchronously

impl<T: Debug, R: Debug> Debug for CustomRwLock<T, R>

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

Formats the value using the given formatter.

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

fn read(&'a self) -> Self::ReadGuard

Reads from the lock, blocking until able.

fn write(&'a self) -> Self::WriteGuard

Writes to the lock, blocking until able.

impl<'a, T, R> RwLockSized<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawRwLock + 'a, 

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

Blocks until reading from the lock and then runs func on the result

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

Blocks until writing to the lock and then runs func on the result

impl<'a, T, R> TimeoutRwLock<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawTimeoutRwLock + 'a, 

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

Reads from the lock with a timeout

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

Writes to the lock with a timeout

impl<'a, T, R> TimeoutRwLockSized<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawTimeoutRwLock + 'a, 

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

Reads from the lock with a timeout running func on the result

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

Writes to the lock with a timeout running func on the result

impl<'a, T, R> TryRwLock<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawTryRwLock + 'a, 

type Item = T

The item stored by this lock

type ReadGuard = CustomReadGuard<'a, T, R>

The guard for reading from this lock

type WriteGuard = CustomWriteGuard<'a, T, R>

The guard for writing to this lock

fn try_read(&'a self) -> Option<Self::ReadGuard>

Tries to read from the lock, returning None if cannot immediately

fn try_write(&'a self) -> Option<Self::WriteGuard>

Tries to write to the lock, returning None if not able to immediately

impl<'a, T, R> TryRwLockSized<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawTryRwLock + 'a, 

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

Tries to read from the lock and runs func on the result

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

Tries to write to the lock and runs func on the result

impl<'a, T, R> AsyncTimeoutUpgradeRwLock<'a> for CustomRwLock<T, R> where
    T: 'a + Send + Sync,
    R: RawAsyncTimeoutUpgradeRwLock + 'a + Send + Sync, 

impl<'a, T, R> AsyncUpgradeRwLock<'a> for CustomRwLock<T, R> where
    T: 'a + Send + Sync,
    R: RawAsyncUpgradeRwLock + 'a + Send + Sync, 

impl<'a, T, R> DowngradeRwLock<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawDowngradeRwLock + 'a, 

impl<T, R> Sync for CustomRwLock<T, R> where
    T: Sync,
    R: Sync, 

impl<'a, T, R> TryUpgradeRwLock<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawTryUpgradeRwLock + 'a, 

impl<'a, T, R> UpgradeRwLock<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawUpgradeRwLock + 'a, 

impl<'a, T, R> UpgradeTimeoutRwLock<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawUpgradeTimeoutRwLock + 'a,