Struct SubscriberBuilder 

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

A builder for initializing a crate::pubsub::Subscriber<Handler>.

Examples

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

Implementations

impl<'a, 'b> SubscriberBuilder<'a, 'b, DefaultHandler>

pub fn callback<F>( self, callback: F, ) -> SubscriberBuilder<'a, 'b, Callback<Sample>>

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

Receive the samples for this subscription with a callback.

Examples

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

pub fn callback_mut<F>( self, callback: F, ) -> SubscriberBuilder<'a, 'b, Callback<Sample>>

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

Receive the samples for this subscription with a mutable callback.

Using this guarantees that your callback will never be called concurrently. If your callback is also accepted by the callback method, we suggest you use it instead of callback_mut.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let mut n = 0;
let subscriber = session
    .declare_subscriber("key/expression")
    .callback_mut(move |_sample| { n += 1; })
    .await
    .unwrap();

pub fn with<Handler>( self, handler: Handler, ) -> SubscriberBuilder<'a, 'b, Handler>

where Handler: IntoHandler<Sample>,

Receive the samples for this subscription with a Handler.

Examples

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());
}

impl<'a, 'b> SubscriberBuilder<'a, 'b, Callback<Sample>>

pub fn background(self) -> SubscriberBuilder<'a, 'b, Callback<Sample>, true>

Register the subscriber callback to be run in background until the session is closed.

Background builder doesn’t return a Subscriber object anymore.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
// no need to assign and keep a variable with a background subscriber
session
    .declare_subscriber("key/expression")
    .callback(|sample| { println!("Received: {} {:?}", sample.key_expr(), sample.payload()); })
    .background()
    .await
    .unwrap();

impl<Handler, const BACKGROUND: bool> SubscriberBuilder<'_, '_, Handler, BACKGROUND>

pub fn allowed_origin(self, origin: Locality) -> Self

Changes the crate::sample::Locality of received publications.

Restricts the matching publications that will be receive by this Subscriber to the ones that have the given crate::sample::Locality.

Trait Implementations

impl<'a, 'b, Handler: Debug, const BACKGROUND: bool> Debug for SubscriberBuilder<'a, 'b, Handler, BACKGROUND>

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

Formats the value using the given formatter.

impl IntoFuture for SubscriberBuilder<'_, '_, Callback<Sample>, true>

type Output = <SubscriberBuilder<'_, '_, Callback<Sample>, true> as Resolvable>::To

The output that the future will produce on completion.

type IntoFuture = Ready<<SubscriberBuilder<'_, '_, Callback<Sample>, 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 SubscriberBuilder<'_, '_, Handler>

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

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

The output that the future will produce on completion.

type IntoFuture = Ready<<SubscriberBuilder<'_, '_, 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 SubscriberBuilder<'_, '_, Callback<Sample>, true>

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

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

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

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

impl Wait for SubscriberBuilder<'_, '_, Callback<Sample>, true>

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

Synchronously execute and wait

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

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

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

Synchronously execute and wait