Struct QuerierBuilder

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

A builder for initializing a 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 QuerierBuilder<'_, '_>

pub fn congestion_control(self, congestion_control: CongestionControl) -> Self

pub fn priority(self, priority: Priority) -> Self

pub fn express(self, is_express: bool) -> Self

impl QuerierBuilder<'_, '_>

pub fn target(self, target: QueryTarget) -> Self

Change the target of the querier queries.

pub fn consolidation<QC: Into<QueryConsolidation>>( self, consolidation: QC, ) -> Self

Change the consolidation mode of the querier queries.

pub fn allowed_destination(self, destination: Locality) -> Self

Restrict the matching queryables that will receive the queries to the ones that have the given Locality.

pub fn timeout(self, timeout: Duration) -> Self

Set queries timeout.

pub fn accept_replies(self, accept: ReplyKeyExpr) -> Self

Available on crate feature unstable only.

By default, only replies whose key expressions intersect

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

with the querier key expression will be received by calls to [`Querier::get`](crate::query::Querier::get) method.

If allowed to through accept_replies(ReplyKeyExpr::Any), queryables may also reply on key expressions that don’t intersect with the querier’s queries.

Trait Implementations

impl<'a, 'b> Debug for QuerierBuilder<'a, 'b>

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

Formats the value using the given formatter.

impl IntoFuture for QuerierBuilder<'_, '_>

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

The output that the future will produce on completion.

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

type To = Result<Querier<'b>, Box<dyn Error + Sync + Send>>

impl Wait for QuerierBuilder<'_, '_>

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

Synchronously execute and wait