Struct Query 

pub struct Query { /* private fields */ }

The request received by a Queryable.

The Query provides all data sent by Querier::get or Session::get: the key expression, the parameters, the payload, and the attachment, if any.

The reply to the query should be made with one of its methods:

• Query::reply to reply with a data Sample of kind Put,
• Query::reply_del to reply with a data Sample of kind Delete,
• Query::reply_err to send an error reply.

The important detail: the Query::key_expr is not the key expression which should be used as the parameter of reply, because it may contain globs. The Queryable’s key expression is the one that should be used. For example, the Query may contain the key expression foo/* and the reply should be sent with foo/bar or foo/baz, depending on the concrete querier.

Implementations

impl Query

pub fn selector(&self) -> Selector<'_>

The full Selector of this Query.

Examples

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

pub fn key_expr(&self) -> &KeyExpr<'static>

The key selector part of this Query.

Examples

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

pub fn parameters(&self) -> &Parameters<'static>

This Query’s selector parameters.

Examples

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

pub fn payload(&self) -> Option<&ZBytes>

This Query’s payload.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .declare_queryable("key/expression")
    .callback(move |query| {
        let payload: Option<&ZBytes> = query.payload();
    })
    .await
    .unwrap();

pub fn payload_mut(&mut self) -> Option<&mut ZBytes>

This Query’s payload (mutable).

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .declare_queryable("key/expression")
    .callback(move |mut query| {
        let payload: Option<&mut ZBytes> = query.payload_mut();
    })
    .await
    .unwrap();

pub fn encoding(&self) -> Option<&Encoding>

This Query’s encoding.

Examples

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

pub fn attachment(&self) -> Option<&ZBytes>

This Query’s attachment.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .declare_queryable("key/expression")
    .callback(move |query| {
        let attachment: Option<&ZBytes> = query.attachment();
    })
    .await
    .unwrap();

pub fn attachment_mut(&mut self) -> Option<&mut ZBytes>

This Query’s attachment (mutable).

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .declare_queryable("key/expression")
    .callback(move |mut query| {
        let attachment: Option<&mut ZBytes> = query.attachment_mut();
    })
    .await
    .unwrap();

pub fn source_info(&self) -> Option<&SourceInfo>

Available on crate feature unstable only.

Gets info on the source of this Query.

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

pub fn reply<'b, TryIntoKeyExpr, IntoZBytes>( &self, key_expr: TryIntoKeyExpr, payload: IntoZBytes, ) -> ReplyBuilder<'_, 'b, ReplyBuilderPut>

where TryIntoKeyExpr: TryInto<KeyExpr<'b>>, <TryIntoKeyExpr as TryInto<KeyExpr<'b>>>::Error: Into<Error>, IntoZBytes: Into<ZBytes>,

Sends a Sample of kind Put as a reply to this Query.

By default, queries only accept replies whose key expression intersects with the query’s. Unless the query has enabled disjoint replies (you can check this through Query::accepts_replies), replying on a disjoint key expression will result in an error when resolving the reply.

pub fn reply_err<IntoZBytes>(&self, payload: IntoZBytes) -> ReplyErrBuilder<'_>

where IntoZBytes: Into<ZBytes>,

Sends a ReplyError as a reply to this Query.

pub fn reply_del<'b, TryIntoKeyExpr>( &self, key_expr: TryIntoKeyExpr, ) -> ReplyBuilder<'_, 'b, ReplyBuilderDelete>

where TryIntoKeyExpr: TryInto<KeyExpr<'b>>, <TryIntoKeyExpr as TryInto<KeyExpr<'b>>>::Error: Into<Error>,

Sends a Sample of kind Delete as a reply to this Query.

By default, queries only accept replies whose key expression intersects with the query’s. Unless the query has enabled disjoint replies (you can check this through Query::accepts_replies), replying on a disjoint key expression will result in an error when resolving the reply.

pub fn accepts_replies(&self) -> ZResult<ReplyKeyExpr>

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 getter allows you to check whether or not a specific query does so.

Examples

let session = zenoh::open(zenoh::Config::default()).await.unwrap();
let queryable = session
    .declare_queryable("key/expression")
    .callback(move |query| { query.accepts_replies(); })
    .await
    .unwrap();

Trait Implementations

impl Clone for Query

fn clone(&self) -> Query

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Query

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

Formats the value using the given formatter.

impl Display for Query

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

Formats the value using the given formatter.

impl<'a> From<&'a Query> for Selector<'a>

fn from(q: &'a Query) -> Self

Converts to this type from the input type.