Struct WatchChannel 

pub struct WatchChannel { /* private fields */ }

Observes changes of the latest state value: holds and updates one value, and all observers (WatchChannel::subscribe) are notified when it changes.

The semantics are “latest value”, not a message queue:

• observers are only guaranteed to eventually see the latest value, not every intermediate change — values overwritten between two notify calls are never re-sent;
• unbounded: a new value simply replaces the old one; there is no queue capacity, and no backpressure;
• observers are independent of each other; how fast one consumes does not affect the others.

Driven by the MessageChannel interface:

• MessageChannel::notify — update the value to the latest message; all observers get notified;
• MessageChannel::ask — not supported (watch has no “reply” concept), returns ChannelError::NotSupported;
• receive side: WatchReceiver::recv waits for a change and takes the latest value.

Implements Clone — every clone is a sender of the same channel, and any clone’s notify notifies all observers.

Example

use molo::{MessageChannel, WatchChannel};

let status = WatchChannel::new();
let sub_a = status.subscribe();
let sub_b = status.subscribe();

status.notify("ready").await?;
assert_eq!(sub_a.recv().await?.text(), "ready");
assert_eq!(sub_b.recv().await?.text(), "ready");

Notes

• the initial value is an empty string: before the first notify, recv keeps waiting;
• when there are no observers (never subscribed, or all observers have been dropped), notify returns ChannelError::NoReceiver — unlike BroadcastChannel, which succeeds silently even with nobody listening, so subscribe first, then notify; the channel itself is not closed, and notify works again after re-subscribing.

Implementations

impl WatchChannel

pub fn new() -> Self

Creates a watch channel whose initial value is an empty string.

Before the first notify, a subscriber’s recv keeps waiting.

pub fn subscribe(&self) -> WatchReceiver

Subscribes to value changes; each observer gets an independent receive end, unaffected by the others.

Trait Implementations

impl Clone for WatchChannel

fn clone(&self) -> WatchChannel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WatchChannel

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

Formats the value using the given formatter.

impl Default for WatchChannel

fn default() -> Self

Returns the “default value” for a type.

impl MessageChannel for WatchChannel

fn ask<'life0, 'life1, 'async_trait>( &'life0 self, _message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, ChannelError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sends a question and waits for a reply (request-response).

fn notify<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), ChannelError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

A one-way notification that does not wait for a reply (broadcast to all receivers).