impl<T: ?Sized, U: ?Sized> OwnedRwLockReadGuard<T, U>

fn map<F, V: ?Sized>(this: Self, f: F) -> OwnedRwLockReadGuard<T, V>
where
    F: FnOnce(&U) -> &V

Makes a new OwnedRwLockReadGuard for a component of the locked data. This operation cannot fail as the OwnedRwLockReadGuard passed in already locked the data.

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

Examples

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockReadGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

# #[tokio::main]
# async fn main() {
let lock = Arc::new(RwLock::new(Foo(1)));

let guard = lock.read_owned().await;
let guard = OwnedRwLockReadGuard::map(guard, |f| &f.0);

assert_eq!(1, *guard);
# }

fn try_map<F, V: ?Sized>(this: Self, f: F) -> Result<OwnedRwLockReadGuard<T, V>, Self>
where
    F: FnOnce(&U) -> Option<&V>

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

This operation cannot fail as the OwnedRwLockReadGuard passed in already locked the data.

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

Examples

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockReadGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

# #[tokio::main]
# async fn main() {
let lock = Arc::new(RwLock::new(Foo(1)));

let guard = lock.read_owned().await;
let guard = OwnedRwLockReadGuard::try_map(guard, |f| Some(&f.0)).expect("should not fail");

assert_eq!(1, *guard);
# }

fn rwlock(this: &Self) -> &Arc<RwLock<T>>

Returns a reference to the original Arc<RwLock>.

Examples

use std::sync::Arc;
use tokio::sync::{RwLock, OwnedRwLockReadGuard};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Foo(u32);

# #[tokio::main]
# async fn main() {
let lock = Arc::new(RwLock::new(Foo(1)));

let guard = lock.clone().read_owned().await;
assert!(Arc::ptr_eq(&lock, OwnedRwLockReadGuard::rwlock(&guard)));

let guard = OwnedRwLockReadGuard::map(guard, |f| &f.0);
assert!(Arc::ptr_eq(&lock, OwnedRwLockReadGuard::rwlock(&guard)));
# }

impl<P, T> Receiver for OwnedRwLockReadGuard<T, U>

impl<T> Any for OwnedRwLockReadGuard<T, U>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for OwnedRwLockReadGuard<T, U>

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

impl<T> BorrowMut for OwnedRwLockReadGuard<T, U>

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

impl<T> From for OwnedRwLockReadGuard<T, U>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToString for OwnedRwLockReadGuard<T, U>

fn to_string(self: &Self) -> String

impl<T, U = T> RefUnwindSafe for OwnedRwLockReadGuard<T, U>

impl<T, U = T> UnwindSafe for OwnedRwLockReadGuard<T, U>

impl<T, U> Freeze for OwnedRwLockReadGuard<T, U>

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

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> Send for OwnedRwLockReadGuard<T, U>

impl<T, U> Sync for OwnedRwLockReadGuard<T, U>

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

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

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

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

impl<T, U> Unpin for OwnedRwLockReadGuard<T, U>

impl<T, U> UnsafeUnpin for OwnedRwLockReadGuard<T, U>

impl<T: ?Sized, U> Debug for OwnedRwLockReadGuard<T, U>

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

impl<T: ?Sized, U> Display for OwnedRwLockReadGuard<T, U>

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

impl<T: ?Sized, U: ?Sized> Deref for OwnedRwLockReadGuard<T, U>

fn deref(self: &Self) -> &U

impl<T: ?Sized, U: ?Sized> Drop for OwnedRwLockReadGuard<T, U>

fn drop(self: &mut Self)