Struct SessionGetBuilder 

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

A builder for configuring a get operation from a Session. The builder resolves to a handler generating a series of Reply for each response received.

Examples

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

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

Implementations

impl<Handler> SessionGetBuilder<'_, '_, 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 SessionGetBuilder<'_, '_, DefaultHandler>

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<Handler> SessionGetBuilder<'_, '_, Handler>

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

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

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

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

Receive the replies for this query with a callback.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .get("key/expression")
    .callback(|reply| {println!("Received {:?}", reply.result());})
    .await
    .unwrap();

pub fn callback_mut<F>( self, callback: F, ) -> SessionGetBuilder<'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

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

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

where Handler: IntoHandler<Reply>,

Receive the replies for this query with a Handler.

Examples

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

impl<Handler> SessionGetBuilder<'_, '_, Handler>

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

where IntoZBytes: Into<ZBytes>,

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

Change the target(s) of the query.

This method allows to specify whether the request should just return the data available in the network which matches the key expression (QueryTarget::BestMatching, default) or if it should arrive to all queryables matching the key expression (QueryTarget::All, QueryTarget::AllComplete).

See also the complete setting of the Queryable

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

Change the consolidation mode of the query.

The multiple replies to a query may arrive from the network. The ConsolidationMode enum defines the strategies of filtering and reordering these replies. The wrapper struct QueryConsolidation allows to set an ConsolidationMode::AUTO mode, which lets the implementation choose the best strategy.

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

Available on crate feature unstable only.

Restrict the matching queryables that will receive the query

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

to the ones that have the given [`Locality`](Locality).

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

Set the query timeout.

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

Available on crate feature unstable only.

See details in ReplyKeyExpr documentation.

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

Queries may or may not accept replies on key expressions that do not intersect with their own key expression. This setter allows you to define whether this get operation accepts such disjoint replies.

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

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

The output that the future will produce on completion.

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

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

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

Synchronously execute and wait