impl<T> RwLock<T>

const fn new(t: T) -> RwLock<T>

Creates a new instance of an RwLock<T> which is unlocked.

Examples

#![feature(nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let lock = RwLock::new(5);

fn get_cloned(self: &Self) -> T
where
    T: Clone

Returns the contained value by cloning it.

Examples

#![feature(nonpoison_rwlock)]
#![feature(lock_value_accessors)]

use std::sync::nonpoison::RwLock;

let mut lock = RwLock::new(7);

assert_eq!(lock.get_cloned(), 7);

fn set(self: &Self, value: T)

Sets the contained value.

Examples

#![feature(nonpoison_rwlock)]
#![feature(lock_value_accessors)]

use std::sync::nonpoison::RwLock;

let mut lock = RwLock::new(7);

assert_eq!(lock.get_cloned(), 7);
lock.set(11);
assert_eq!(lock.get_cloned(), 11);

fn replace(self: &Self, value: T) -> T

Replaces the contained value with value, and returns the old contained value.

Examples

#![feature(nonpoison_rwlock)]
#![feature(lock_value_accessors)]

use std::sync::nonpoison::RwLock;

let mut lock = RwLock::new(7);

assert_eq!(lock.replace(11), 7);
assert_eq!(lock.get_cloned(), 11);

impl<T: ?Sized> RwLock<T>

fn read(self: &Self) -> RwLockReadGuard<'_, T>

Locks this RwLock with shared read access, blocking the current thread until it can be acquired.

The calling thread will be blocked until there are no more writers which hold the lock. There may be other readers currently inside the lock when this method returns. This method does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

Returns an RAII guard which will release this thread's shared access once it is dropped.

Panics

This function might panic when called if the lock is already held by the current thread.

Examples

#![feature(nonpoison_rwlock)]

use std::sync::Arc;
use std::sync::nonpoison::RwLock;
use std::thread;

let lock = Arc::new(RwLock::new(1));
let c_lock = Arc::clone(&lock);

let n = lock.read();
assert_eq!(*n, 1);

thread::spawn(move || {
    let r = c_lock.read();
}).join().unwrap();

fn try_read(self: &Self) -> TryLockResult<RwLockReadGuard<'_, T>>

Attempts to acquire this RwLock with shared read access.

If the access could not be granted at this time, then Err is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

This function does not block.

This function does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

Errors

This function will return the WouldBlock error if the RwLock could not be acquired because it was already locked exclusively.

Examples

#![feature(nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let lock = RwLock::new(1);

match lock.try_read() {
    Ok(n) => assert_eq!(*n, 1),
    Err(_) => unreachable!(),
};

fn write(self: &Self) -> RwLockWriteGuard<'_, T>

Locks this RwLock with exclusive write access, blocking the current thread until it can be acquired.

This function will not return while other writers or other readers currently have access to the lock.

Returns an RAII guard which will drop the write access of this RwLock when dropped.

Panics

This function might panic when called if the lock is already held by the current thread.

Examples

#![feature(nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let lock = RwLock::new(1);

let mut n = lock.write();
*n = 2;

assert!(lock.try_read().is_err());

fn try_write(self: &Self) -> TryLockResult<RwLockWriteGuard<'_, T>>

Attempts to lock this RwLock with exclusive write access.

If the lock could not be acquired at this time, then Err is returned. Otherwise, an RAII guard is returned which will release the lock when it is dropped.

This function does not block.

This function does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

Errors

This function will return the WouldBlock error if the RwLock could not be acquired because it was already locked.

Examples

#![feature(nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let lock = RwLock::new(1);

let n = lock.read();
assert_eq!(*n, 1);

assert!(lock.try_write().is_err());

fn into_inner(self: Self) -> T
where
    T: Sized

Consumes this RwLock, returning the underlying data.

Examples

#![feature(nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let lock = RwLock::new(String::new());
{
    let mut s = lock.write();
    *s = "modified".to_owned();
}
assert_eq!(lock.into_inner(), "modified");

fn get_mut(self: &mut Self) -> &mut T

Returns a mutable reference to the underlying data.

Since this call borrows the RwLock mutably, no actual locking needs to take place -- the mutable borrow statically guarantees no new locks can be acquired while this reference exists. Note that this method does not clear any previously abandoned locks (e.g., via [forget()] on a RwLockReadGuard or RwLockWriteGuard).

Examples

#![feature(nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let mut lock = RwLock::new(0);
*lock.get_mut() = 10;
assert_eq!(*lock.read(), 10);

const fn data_ptr(self: &Self) -> *mut T

Returns a raw pointer to the underlying data.

The returned pointer is always non-null and properly aligned, but it is the user's responsibility to ensure that any reads and writes through it are properly synchronized to avoid data races, and that it is not read or written through after the lock is dropped.

fn with<F, R>(self: &Self, f: F) -> R
where
    F: FnOnce(&T) -> R

Locks this RwLock with shared read access to the underlying data by passing a reference to the given closure.

This method acquires the lock, calls the provided closure with a reference to the data, and returns the result of the closure. The lock is released after the closure completes, even if it panics.

Examples

#![feature(lock_value_accessors, nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let rwlock = RwLock::new(2);
let result = rwlock.with(|data| *data + 3);

assert_eq!(result, 5);

fn with_mut<F, R>(self: &Self, f: F) -> R
where
    F: FnOnce(&mut T) -> R

Locks this RwLock with exclusive write access to the underlying data by passing a mutable reference to the given closure.

This method acquires the lock, calls the provided closure with a mutable reference to the data, and returns the result of the closure. The lock is released after the closure completes, even if it panics.

Examples

#![feature(lock_value_accessors, nonpoison_rwlock)]

use std::sync::nonpoison::RwLock;

let rwlock = RwLock::new(2);

let result = rwlock.with_mut(|data| {
    *data += 3;

    *data + 5
});

assert_eq!(*rwlock.read(), 5);
assert_eq!(result, 10);

impl<T> Any for RwLock<T>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for RwLock<T>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for RwLock<T>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> Freeze for RwLock<T>

impl<T> From for RwLock<T>

fn from(t: T) -> Self

Creates a new instance of an RwLock<T> which is unlocked. This is equivalent to RwLock::new.

impl<T> From for RwLock<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> From for RwLock<T>

fn from(t: never) -> T

impl<T> RefUnwindSafe for RwLock<T>

impl<T> Unpin for RwLock<T>

impl<T> UnsafeUnpin for RwLock<T>

impl<T> UnwindSafe for RwLock<T>

impl<T, U> Into for RwLock<T>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for RwLock<T>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for RwLock<T>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: ?Sized + Send + Sync> Sync for RwLock<T>

impl<T: ?Sized + Send> Send for RwLock<T>

impl<T: ?Sized + fmt::Debug> Debug for RwLock<T>

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

impl<T: Default> Default for RwLock<T>

fn default() -> RwLock<T>

Creates a new RwLock<T>, with the Default value for T.