Struct QuerierGetBuilder

pub struct QuerierGetBuilder<'a, 'b, Handler> { /* private fields */ }

A builder for initializing a query to be sent from the querier.

Examples

use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let querier = session.declare_querier("key/expression")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
let replies = querier
    .get()
    .parameters("value>1")
    .await
    .unwrap();
while let Ok(reply) = replies.recv_async().await {
    println!("Received {:?}", reply.result())
}

Implementations

impl<Handler> QuerierGetBuilder<'_, '_, Handler>

pub fn source_info(self, source_info: SourceInfo) -> Self

Available on crate feature unstable only.

pub fn attachment<T: Into<OptionZBytes>>(self, attachment: T) -> Self

impl<Handler> QuerierGetBuilder<'_, '_, Handler>

pub fn encoding<T: Into<Encoding>>(self, encoding: T) -> Self

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

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

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

Receive the replies for this query with a callback.

Examples

use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let querier = session.declare_querier("key/expression")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
let _ = querier
    .get()
    .callback(|reply| {println!("Received {:?}", reply.result());})
    .await
    .unwrap();

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

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

Receive the replies for this query 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

use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let querier = session.declare_querier("key/expression")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
let mut n = 0;
let _ = querier
    .get()
    .callback_mut(move |reply| {n += 1;})
    .await
    .unwrap();

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

where Handler: IntoHandler<Reply>,

Receive the replies for this query with a Handler.

Examples

use zenoh::{query::{ConsolidationMode, QueryTarget}};

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let querier = session.declare_querier("key/expression")
    .target(QueryTarget::All)
    .consolidation(ConsolidationMode::None)
    .await
    .unwrap();
let replies = querier
    .get()
    .with(flume::bounded(32))
    .await
    .unwrap();
while let Ok(reply) = replies.recv_async().await {
    println!("Received {:?}", reply.result());
}

impl<'b, Handler> QuerierGetBuilder<'_, 'b, Handler>

pub fn payload<IntoZBytes>(self, payload: IntoZBytes) -> Self

where IntoZBytes: Into<ZBytes>,

Set the query payload.

pub fn parameters<P>(self, parameters: P) -> Self

where P: Into<Parameters<'b>>,

Set the query selector parameters.

Trait Implementations

impl<'a, 'b, Handler: Debug> Debug for QuerierGetBuilder<'a, 'b, Handler>

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

Formats the value using the given formatter.

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

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

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

The output that the future will produce on completion.

type IntoFuture = Ready<<QuerierGetBuilder<'_, '_, 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<Handler> Resolvable for QuerierGetBuilder<'_, '_, Handler>

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

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

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

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

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

Synchronously execute and wait