Struct RwLockWriteGuard 

pub struct RwLockWriteGuard<'a, R: RawRwLock, T: ?Sized> { /* private fields */ }

An RAII guard which releases exclusive write access when dropped.

This structure is created by the write and try_write methods on RwLock.

Implementations

impl<'a, R: RawRwLock + 'a, T: ?Sized + 'a> RwLockWriteGuard<'a, R, T>

pub fn rwlock(s: &Self) -> &'a RwLock<R, T>

Returns a reference to the original reader-writer lock object.

pub fn map<U: ?Sized, F>(s: Self, f: F) -> MappedRwLockWriteGuard<'a, R, U>

where F: FnOnce(&mut T) -> &mut U,

Makes a new MappedRwLockWriteGuard for a component of the locked data.

This is an associated function that needs to be used as RwLockWriteGuard::map(...). A method would interfere with methods of the same name on the contents of the locked data.

Panics

If f panics, the original guard is dropped.

pub fn try_map<U: ?Sized, F>( s: Self, f: F, ) -> Result<MappedRwLockWriteGuard<'a, R, U>, Self>

where F: FnOnce(&mut T) -> Option<&mut U>,

Attempts to make a new MappedRwLockWriteGuard for a component of the locked data. The original guard is returned if the closure returns None.

This is an associated function that needs to be used as RwLockWriteGuard::try_map(...). A method would interfere with methods of the same name on the contents of the locked data.

Panics

If f panics, the original guard is dropped.

pub fn try_map_or_err<U: ?Sized, F, E>( s: Self, f: F, ) -> Result<MappedRwLockWriteGuard<'a, R, U>, (Self, E)>

where F: FnOnce(&mut T) -> Result<&mut U, E>,

Attempts to make a new MappedRwLockWriteGuard for a component of the locked data. The original guard is returned alongside arbitrary user data if the closure returns Err.

This is an associated function that needs to be used as RwLockWriteGuard::try_map_or_err(...). A method would interfere with methods of the same name on the contents of the locked data.

Panics

If f panics, the original guard is dropped.

pub fn unlocked<F, U>(s: &mut Self, f: F) -> U

where F: FnOnce() -> U,

Temporarily unlocks the RwLock to execute the given function.

This is safe because &mut guarantees that there exist no other references to the data protected by the RwLock.

Aborts

Aborts if re-locking the RwLock panics.

impl<'a, R: RawRwLockDowngrade + 'a, T: ?Sized + 'a> RwLockWriteGuard<'a, R, T>

pub fn downgrade(s: Self) -> RwLockReadGuard<'a, R, T>

Atomically downgrades a write lock into a read lock without allowing any writers to take exclusive access of the lock in the meantime.

Note that if there are any writers currently waiting to take the lock then other readers may not be able to acquire the lock even if it was downgraded.

impl<'a, R: RawRwLockUpgradeDowngrade + 'a, T: ?Sized + 'a> RwLockWriteGuard<'a, R, T>

pub fn downgrade_to_upgradable(s: Self) -> RwLockUpgradableReadGuard<'a, R, T>

Atomically downgrades a write lock into an upgradable read lock without allowing any writers to take exclusive access of the lock in the meantime.

Note that if there are any writers currently waiting to take the lock then other readers may not be able to acquire the lock even if it was downgraded.

impl<'a, R: RawRwLockFair + 'a, T: ?Sized + 'a> RwLockWriteGuard<'a, R, T>

pub fn unlock_fair(s: Self)

Unlocks the RwLock using a fair unlock protocol.

A fair unlock gives waiting threads priority over new acquisition attempts. This can prevent starvation, but may reduce throughput by forcing a context switch.

pub fn unlocked_fair<F, U>(s: &mut Self, f: F) -> U

where F: FnOnce() -> U,

Temporarily unlocks the RwLock to execute the given function.

The RwLock is unlocked using a fair unlock protocol.

This is safe because &mut guarantees that there exist no other references to the data protected by the RwLock.

Aborts

Aborts if re-locking the RwLock panics.

pub fn bump(s: &mut Self)

Temporarily yields the RwLock to a waiting thread if there is one.

This method is functionally equivalent to calling unlock_fair followed by write, however it can be much more efficient in the case where there are no waiting threads.

Trait Implementations

impl<'a, R: RawRwLock + 'a, T: Debug + ?Sized + 'a> Debug for RwLockWriteGuard<'a, R, T>

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

Formats the value using the given formatter.

impl<'a, R: RawRwLock + 'a, T: ?Sized + 'a> Deref for RwLockWriteGuard<'a, R, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'a, R: RawRwLock + 'a, T: ?Sized + 'a> DerefMut for RwLockWriteGuard<'a, R, T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<'a, R: RawRwLock + 'a, T: Display + ?Sized + 'a> Display for RwLockWriteGuard<'a, R, T>

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

Formats the value using the given formatter.

impl<'a, R: RawRwLock + 'a, T: ?Sized + 'a> Drop for RwLockWriteGuard<'a, R, T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.