Struct ToolListWatch 

pub struct ToolListWatch { /* private fields */ }

Stream of ToolListChange events returned by crate::adapter::net::MeshNode::watch_tools. Implements futures::Stream<Item = ToolListChange>.

Backed by a bounded mpsc; a slow consumer applies backpressure to the diff task (which blocks on the next send().await) rather than queueing events without bound.

Two ways to end the watch:

• Drop the ToolListWatch — the diff task observes the closed receiver (tx.closed()) on its next wake and exits.
• Call Self::cancel — wakes the diff task immediately even if it’s parked on the fold change signal with no consumer reading. This is the path FFI bindings use: a blocking next parked on the receiver can’t be interrupted by dropping the receiver (the blocked recv owns it), so the cancel fires the task to exit, which drops the sender and unblocks the parked recv with None.

Implementations

impl ToolListWatch

pub fn cancel(&self)

Signal the diff task to stop. Idempotent. Wakes the task even when it’s parked on the fold change signal, so a consumer blocked in a synchronous next (e.g. an FFI binding) unblocks promptly: the task exits, drops its sender, and the blocked recv returns None.

pub fn cancel_handle(&self) -> Arc<Notify>

Clone the cancel handle so a holder separate from the receiver (e.g. an FFI handle that has taken the receiver out to block on it) can fire cancellation. Firing it has the same effect as Self::cancel.

pub async fn recv(&mut self) -> Option<ToolListChange>

Receive the next change event. Returns None when the diff task exits (consumer dropped the watch, or Self::cancel fired). Most callers should treat the watch handle as a stream and .next().await on it instead.

pub fn try_recv(&mut self) -> Option<ToolListChange>

Non-blocking peek: returns the next change if one is already queued, otherwise None. Useful for poll-style consumers that want to drain without waiting.

Trait Implementations

impl Stream for ToolListWatch

type Item = ToolListChange

Values yielded by the stream.

fn poll_next( self: Pin<&mut ToolListWatch>, cx: &mut Context<'_>, ) -> Poll<Option<<ToolListWatch as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.