Struct QueryableBuilder 

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

A builder for initializing a Queryable. Returned by the Session::declare_queryable method.

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>

Make the queryable run in the background until the session is closed.

The 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. When queryable is declared as “complete”, it promises to have all the data associated with its key expression, so it’s not necessary to query other nodes for data matching its key expression.

E.g. a queryable serving key expression foo/* is “complete”. The queryer requests data matching foo/bar and gets data from this queryable only even if there are other queryables matching foo/bar.

But for “complete” queryable serving key expression foo/bar the request for foo/* will be sent to other queryables as well as the data from this queryable doesn’t cover the whole key expression foo/*.

This is default behavior which corresponds to QueryTarget::BestMatching parameter of querier’s target.

It’s also possible to forcibly request all available queryables with QueryTarget::All parameter, or to request only “complete” ones with QueryTarget::AllComplete parameter.

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

Restrict the matching queries that will be received 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