Struct concurrency_traits::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,
    R: RawAsyncRwLock + 'a, 

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

The read guard for async reading

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

The write guard for async writing

type ReadFuture = Pin<Box<dyn Future<Output = Self::AsyncReadGuard> + 'a>>

The future returned by read_async

type WriteFuture = Pin<Box<dyn Future<Output = Self::AsyncWriteGuard> + 'a>>

The future returned by write_async

fn read_async(&'a self) -> Self::ReadFuture

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

fn write_async(&'a self) -> Self::WriteFuture

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

impl<'a, T, R> AsyncRwLockSized<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawAsyncRwLock + 'a, 

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

Reads from the lock and runs func on the result asynchronously

fn write_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, 

Writes to the lock and runs func on the result asynchronously

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

type ReadTimeoutFuture = Pin<Box<dyn Future<Output = Option<Self::AsyncReadGuard>> + 'a>>

The future returned by AsyncTimeoutRwLock::read_timeout_async

type WriteTimeoutFuture = Pin<Box<dyn Future<Output = Option<Self::AsyncWriteGuard>> + 'a>>

The future returned by AsyncTimeoutRwLock::write_timeout_async

fn read_timeout_async(&'a self, timeout: Duration) -> Self::ReadTimeoutFuture

Reads from the lock with a timeout asynchronously

fn write_timeout_async(&'a self, timeout: Duration) -> Self::WriteTimeoutFuture

Writes to the lock with a timeout asynchronously

impl<'a, T, R> AsyncTimeoutRwLockSized<'a> for CustomRwLock<T, R> where
    T: 'a,
    R: RawAsyncTimeoutRwLock + 'a, 

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

Reads form the lock with a timeout running func on the result asynchronously

fn write_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, 

Writes to the lock with a timeout running func on the result 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