Struct QueryableBuilder

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

A builder for initializing a Queryable.

Examples

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

Implementations

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

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

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

Receive the queries for this queryable with a callback.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .declare_queryable("key/expression")
    .callback(|query| {println!(">> Handling query '{}'", query.selector());})
    .await
    .unwrap();

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

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

Receive the queries for this Queryable 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 queryable = session
    .declare_queryable("key/expression")
    .callback_mut(move |query| {n += 1;})
    .await
    .unwrap();

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

where Handler: IntoHandler<Query>,

Receive the queries for this Queryable with a Handler.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .declare_queryable("key/expression")
    .with(flume::bounded(32))
    .await
    .unwrap();
while let Ok(query) = queryable.recv_async().await {
    println!(">> Handling query '{}'", query.selector());
}

impl<'a, 'b> QueryableBuilder<'a, 'b, Callback<Query>>

pub fn background(self) -> QueryableBuilder<'a, 'b, Callback<Query>, true>

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

Background builder doesn’t return a Queryable object anymore.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
// no need to assign and keep a variable with a background queryable
session
    .declare_queryable("key/expression")
    .callback(|query| {println!(">> Handling query '{}'", query.selector());})
    .background()
    .await
    .unwrap();

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

pub fn complete(self, complete: bool) -> Self

Change queryable completeness.

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

Available on crate feature unstable only.

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

Restrict the matching queries that will be receive by this Queryable to the ones that have the given Locality.

Trait Implementations

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

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

Formats the value using the given formatter.

impl IntoFuture for QueryableBuilder<'_, '_, Callback<Query>, true>

type Output = <QueryableBuilder<'_, '_, Callback<Query>, true> as Resolvable>::To

The output that the future will produce on completion.

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

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

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

The output that the future will produce on completion.

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

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

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

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

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

impl Wait for QueryableBuilder<'_, '_, Callback<Query>, true>

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

Synchronously execute and wait

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

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

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

Synchronously execute and wait