Struct Subscriber

#[non_exhaustive]
pub struct Subscriber<Handler> { /* private fields */ }

A subscriber that provides data through a Handler.

Subscribers can be created from a zenoh Session with the declare_subscriber function.

Callback subscribers will run in background until the session is closed, or until it is undeclared. On the other hand, subscribers with a handler are automatically undeclared when dropped.

Examples

Using callback:

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
session
    .declare_subscriber("key/expression")
    .callback(|sample| { println!("Received: {} {:?}", sample.key_expr(), sample.payload()) })
    .await
    .unwrap();
// subscriber run in background until the session is closed

Using channel handler:

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let subscriber = session
    .declare_subscriber("key/expression")
    .with(flume::bounded(32))
    .await
    .unwrap();
while let Ok(sample) = subscriber.recv_async().await {
    println!("Received: {} {:?}", sample.key_expr(), sample.payload());
}
// subscriber is undeclared at the end of the scope

Implementations

impl<Handler> Subscriber<Handler>

pub fn id(&self) -> EntityGlobalId

Available on crate feature unstable only.

Returns the EntityGlobalId of this Subscriber.

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

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let subscriber = session.declare_subscriber("key/expression")
    .await
    .unwrap();
let subscriber_id = subscriber.id();

pub fn key_expr(&self) -> &KeyExpr<'static>

Returns the KeyExpr this subscriber subscribes to.

pub fn handler(&self) -> &Handler

Returns a reference to this subscriber’s handler. An handler is anything that implements crate::handlers::IntoHandler. The default handler is crate::handlers::DefaultHandler.

pub fn handler_mut(&mut self) -> &mut Handler

Returns a mutable reference to this subscriber’s handler. An handler is anything that implements crate::handlers::IntoHandler. The default handler is crate::handlers::DefaultHandler.

pub fn undeclare(self) -> SubscriberUndeclaration<Handler>

where Handler: Send,

Undeclare the Subscriber.

This subscriber’s crate::handlers::Callback will be dropped as part of the undeclaration.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let subscriber = session.declare_subscriber("key/expression")
    .await
    .unwrap();
subscriber.undeclare().await.unwrap();

Trait Implementations

impl<Handler: Debug> Debug for Subscriber<Handler>

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

Formats the value using the given formatter.

impl<Handler> DerefMut for Subscriber<Handler>

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

Mutably dereferences the value.

impl<Handler> Drop for Subscriber<Handler>

fn drop(&mut self)

Executes the destructor for this type.

impl<Handler> Deref for Subscriber<Handler>

type Target = Handler

The resulting type after dereferencing.

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

Dereferences the value.