Struct TransportEventsListenerBuilder 

pub struct TransportEventsListenerBuilder<'a, Handler, const BACKGROUND: bool = false> { /* private fields */ }

Available on crate feature unstable only.

A builder returned by SessionInfo::transport_events_listener() that allows subscribing to transport lifecycle events.

This API has been marked as unstable: it works as advertised, but it may be changed in a future release.

Examples

use zenoh::sample::SampleKind;

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let events = session.info()
    .transport_events_listener()
    .history(true)
    .with(flume::bounded(32))
    .await
    .expect("Failed to declare transport events listener");

while let Ok(event) = events.recv_async().await {
    match event.kind() {
        SampleKind::Put => println!("Transport opened: {}", event.transport().zid()),
        SampleKind::Delete => println!("Transport closed"),
    }
}

Implementations

impl<'a, Handler> TransportEventsListenerBuilder<'a, Handler>

pub fn history(self, enabled: bool) -> Self

Enable history.

Send events for existing transports before live events.

pub fn with<H>(self, handler: H) -> TransportEventsListenerBuilder<'a, H>

where H: IntoHandler<TransportEvent>,

Use a custom handler (channel, callback, etc.)

pub fn callback<F>( self, callback: F, ) -> TransportEventsListenerBuilder<'a, Callback<TransportEvent>>

where F: Fn(TransportEvent) + Send + Sync + 'static,

Provide a callback to handle events

pub fn callback_mut<F>( self, callback: F, ) -> TransportEventsListenerBuilder<'a, Callback<TransportEvent>>

where F: FnMut(TransportEvent) + Send + Sync + 'static,

Provide a mutable callback which is never called concurrently. If the callback can be accepted by callback, prefer using that instead for better performance.

impl<'a> TransportEventsListenerBuilder<'a, Callback<TransportEvent>>

pub fn background( self, ) -> TransportEventsListenerBuilder<'a, Callback<TransportEvent>, true>

Run the listener in the background, automatically dropping the handler when done.

Examples

use zenoh::sample::SampleKind;

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
// no need to assign and keep a variable for a background listener
session.info()
    .transport_events_listener()
    .callback(|event| {
        match event.kind() {
            SampleKind::Put => println!("Transport opened: {}", event.transport().zid()),
            SampleKind::Delete => println!("Transport closed"),
        }
    })
    .background()
    .await
    .unwrap();

Trait Implementations

impl IntoFuture for TransportEventsListenerBuilder<'_, Callback<TransportEvent>, true>

type Output = <TransportEventsListenerBuilder<'_, Callback<TransportEvent>, true> as Resolvable>::To

The output that the future will produce on completion.

type IntoFuture = Ready<<TransportEventsListenerBuilder<'_, Callback<TransportEvent>, true> as Resolvable>::To>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<Handler> IntoFuture for TransportEventsListenerBuilder<'_, Handler>

where Handler: IntoHandler<TransportEvent> + Send, Handler::Handler: Send,

type Output = <TransportEventsListenerBuilder<'_, Handler> as Resolvable>::To

The output that the future will produce on completion.

type IntoFuture = Ready<<TransportEventsListenerBuilder<'_, Handler> as Resolvable>::To>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl Resolvable for TransportEventsListenerBuilder<'_, Callback<TransportEvent>, true>

type To = Result<(), Box<dyn Error + Sync + Send>>

impl<Handler> Resolvable for TransportEventsListenerBuilder<'_, Handler>

where Handler: IntoHandler<TransportEvent> + Send, Handler::Handler: Send,

type To = Result<TransportEventsListener<<Handler as IntoHandler<TransportEvent>>::Handler>, Box<dyn Error + Sync + Send>>

impl Wait for TransportEventsListenerBuilder<'_, Callback<TransportEvent>, true>

fn wait(self) -> <Self as Resolvable>::To

Synchronously execute and wait

impl<Handler> Wait for TransportEventsListenerBuilder<'_, Handler>

where Handler: IntoHandler<TransportEvent> + Send, Handler::Handler: Send,

fn wait(self) -> Self::To

Synchronously execute and wait