Struct Ref

pub struct Ref<'a, T> { /* private fields */ }

Returns a reference to the inner value.

Outstanding borrows hold a read lock on the inner value. This means that long-lived borrows could cause the producer half to block. It is recommended to keep the borrow as short-lived as possible. Additionally, if you are running in an environment that allows !Send futures, you must ensure that the returned Ref type is never held alive across an .await point, otherwise, it can lead to a deadlock.

The priority policy of the lock is dependent on the underlying lock implementation, and this type does not guarantee that any particular policy will be used. In particular, a producer which is waiting to acquire the lock in send might or might not block concurrent calls to borrow, e.g.:

Potential deadlock example 
// Task 1 (on thread A)    |  // Task 2 (on thread B)
let _ref1 = rx.borrow();   |
                           |  // will block
                           |  let _ = tx.send(());
// may deadlock            |
let _ref2 = rx.borrow();   |

Implementations

impl<'a, T> Ref<'a, T>

fn has_changed(&self) -> bool

Indicates if the borrowed value is considered as changed since the last time it has been marked as seen.

Unlike [Receiver::has_changed()], this method does not fail if the channel is closed.

When borrowed from the Sender this function will always return false.

Examples

use tokio::sync::watch;

# #[tokio::main(flavor = "current_thread")]
# async fn main() {
let (tx, mut rx) = watch::channel("hello");

tx.send("goodbye").unwrap();
// The sender does never consider the value as changed.
assert!(!tx.borrow().has_changed());

// Drop the sender immediately, just for testing purposes.
drop(tx);

// Even if the sender has already been dropped...
assert!(rx.has_changed().is_err());
// ...the modified value is still readable and detected as changed.
assert_eq!(*rx.borrow(), "goodbye");
assert!(rx.borrow().has_changed());

// Read the changed value and mark it as seen.
{
    let received = rx.borrow_and_update();
    assert_eq!(*received, "goodbye");
    assert!(received.has_changed());
    // Release the read lock when leaving this scope.
}

// Now the value has already been marked as seen and could
// never be modified again (after the sender has been dropped).
assert!(!rx.borrow().has_changed());
# }

Trait Implementations

impl<'a, T: Debug> Debug for Ref<'a, T>

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

impl<T> Deref for Ref<'_, T>

type Target = T;
fn deref(&self) -> &T

Auto Trait Implementations

impl<'a, T> !RefUnwindSafe for Ref<'a, T>

impl<'a, T> !Send for Ref<'a, T>

impl<'a, T> !UnwindSafe for Ref<'a, T>

impl<'a, T> Freeze for Ref<'a, T> where RwLockReadGuard<'a, T>: Freeze,

impl<'a, T> Sync for Ref<'a, T> where RwLockReadGuard<'a, T>: Sync,

impl<'a, T> Unpin for Ref<'a, T> where RwLockReadGuard<'a, T>: Unpin,

impl<'a, T> UnsafeUnpin for Ref<'a, T> where RwLockReadGuard<'a, T>: UnsafeUnpin,

Blanket Implementations

impl<P, T> Receiver for Ref<'a, T> where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T;

impl<T> Any for Ref<'a, T> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Ref<'a, T> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Ref<'a, T> where T: ?Sized,

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

impl<T> From<T> for Ref<'a, T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for Ref<'a, T> where U: From<T>,

fn into(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<U> for Ref<'a, T> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Ref<'a, T> where U: TryFrom<T>,

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