Struct NodeHandle 

pub struct NodeHandle { /* private fields */ }

NodeHandle to be passed to the children (Stage)

Methods from Deref<Target = UnboundedSender<NodeEvent>>

pub fn send(&self, message: T) -> Result<(), SendError<T>>

Attempts to send a message on this UnboundedSender without blocking.

This method is not marked async because sending a message to an unbounded channel never requires any form of waiting. Because of this, the send method can be used in both synchronous and asynchronous code without problems.

If the receive half of the channel is closed, either due to close being called or the UnboundedReceiver having been dropped, this function returns an error. The error includes the value passed to send.

pub async fn closed(&self)

Completes when the receiver has dropped.

This allows the producers to get notified when interest in the produced values is canceled and immediately stop doing work.

Cancel safety

This method is cancel safe. Once the channel is closed, it stays closed forever and all future calls to closed will return immediately.

Examples

use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let (tx1, rx) = mpsc::unbounded_channel::<()>();
    let tx2 = tx1.clone();
    let tx3 = tx1.clone();
    let tx4 = tx1.clone();
    let tx5 = tx1.clone();
    tokio::spawn(async move {
        drop(rx);
    });

    futures::join!(
        tx1.closed(),
        tx2.closed(),
        tx3.closed(),
        tx4.closed(),
        tx5.closed()
    );
}

pub fn is_closed(&self) -> bool

Checks if the channel has been closed. This happens when the UnboundedReceiver is dropped, or when the UnboundedReceiver::close method is called.

let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<()>();
assert!(!tx.is_closed());

let tx2 = tx.clone();
assert!(!tx2.is_closed());

drop(rx);
assert!(tx.is_closed());
assert!(tx2.is_closed());

pub fn same_channel(&self, other: &UnboundedSender<T>) -> bool

Returns true if senders belong to the same channel.

Examples

let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<()>();
let  tx2 = tx.clone();
assert!(tx.same_channel(&tx2));

let (tx3, rx3) = tokio::sync::mpsc::unbounded_channel::<()>();
assert!(!tx3.same_channel(&tx2));

Trait Implementations

impl AknShutdown<Stage> for NodeHandle

fn aknowledge_shutdown<'async_trait>( self, _state: Stage, _status: Result<(), Need>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait,

Child aknowledging shutdown for its supervisor

impl Clone for NodeHandle

fn clone(&self) -> NodeHandle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Deref for NodeHandle

type Target = UnboundedSender<NodeEvent>

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for NodeHandle

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl EventLoop<NodeHandle> for Stage

fn event_loop<'life0, 'life1, 'async_trait>( &'life0 mut self, _status: Result<(), Need>, supervisor: &'life1 mut Option<NodeHandle>, ) -> Pin<Box<dyn Future<Output = Result<(), Need>> + Send + 'async_trait>>

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

impl Init<NodeHandle> for Stage

fn init<'life0, 'life1, 'async_trait>( &'life0 mut self, status: Result<(), Need>, supervisor: &'life1 mut Option<NodeHandle>, ) -> Pin<Box<dyn Future<Output = Result<(), Need>> + Send + 'async_trait>>

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

impl Shutdown for NodeHandle

fn shutdown(self) -> Option<Self>

where Self: Sized,

Shutdown the service

impl Terminating<NodeHandle> for Stage

fn terminating<'life0, 'life1, 'async_trait>( &'life0 mut self, _status: Result<(), Need>, _supervisor: &'life1 mut Option<NodeHandle>, ) -> Pin<Box<dyn Future<Output = Result<(), Need>> + Send + 'async_trait>>

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

impl ActorBuilder<NodeHandle> for StageBuilder