internal Query::empty doesn't require self (#1783)

* internal Query::empty doesn't require self

* Add dummy key expression methods for internal use

* clippy fixes

* no need to mark Sample::empty() unsafe anymore

* Reply::empty() is safe, as well as Sample::empty()

Author: milyin

zenoh/Cargo.toml

@@ -107,7 +107,7 @@ zenoh-codec = { workspace = true }
 zenoh-collections = { workspace = true, features = ["std"] }
 zenoh-config = { workspace = true }
 zenoh-core = { workspace = true }
-zenoh-keyexpr = { workspace = true }
+zenoh-keyexpr = { workspace = true, features = ["internal"] }
 zenoh-link = { workspace = true }
 zenoh-macros = { workspace = true }
 zenoh-plugin-trait = { workspace = true }

zenoh/src/api/key_expr.rs

@@ -89,6 +89,9 @@ impl KeyExpr<'static> {
         )))
     }
 }
+
+static KEYEXPR_DUMMY: &keyexpr = unsafe { keyexpr::from_str_unchecked("dummy") };
+
 impl<'a> KeyExpr<'a> {
     /// Equivalent to `<KeyExpr as TryFrom>::try_from(t)`.
     ///
@@ -103,6 +106,31 @@ impl<'a> KeyExpr<'a> {
         Self::try_from(t)
     }
 
+    /// Constructs key expression object to be used as dummy value
+    /// for empty objects. This method is not supposed to be called in user code,
+    /// but may be used in language bindings (zenoh-c)
+    #[zenoh_macros::internal]
+    pub fn dummy() -> Self {
+        Self(KeyExprInner::Borrowed(KEYEXPR_DUMMY))
+    }
+
+    #[cfg(not(feature = "internal"))]
+    pub(crate) fn dummy() -> Self {
+        Self(KeyExprInner::Borrowed(KEYEXPR_DUMMY))
+    }
+
+    /// Checks if the key expression is the dummy one.
+    /// This method is not supposed to be called in user code,
+    /// but may be used in language bindings (zenoh-c)
+    #[zenoh_macros::internal]
+    pub fn is_dummy(&self) -> bool {
+        let Self(inner) = self;
+        let KeyExprInner::Borrowed(key_expr) = inner else {
+            return false;
+        };
+        std::ptr::eq(*key_expr, KEYEXPR_DUMMY)
+    }
+
     /// Constructs a new [`KeyExpr`] aliasing `self`.
     ///
     /// Note that [`KeyExpr`] (as well as [`OwnedKeyExpr`]) use reference counters internally, so you're probably better off using clone.

zenoh/src/api/query.rs

@@ -158,7 +158,7 @@ impl Reply {
 
     /// Constructs an uninitialized empty Reply.
     #[zenoh_macros::internal]
-    pub unsafe fn empty() -> Self {
+    pub fn empty() -> Self {
         Reply {
             result: Ok(Sample::empty()),
             #[cfg(feature = "unstable")]

zenoh/src/api/queryable.rs

@@ -34,6 +34,8 @@ use {
 
 #[zenoh_macros::unstable]
 use crate::api::selector::ZenohParameters;
+#[zenoh_macros::internal]
+use crate::net::primitives::DummyPrimitives;
 use crate::{
     api::{
         builders::reply::{ReplyBuilder, ReplyBuilderDelete, ReplyBuilderPut, ReplyErrBuilder},
@@ -57,6 +59,19 @@ pub(crate) struct QueryInner {
     pub(crate) primitives: Arc<dyn Primitives>,
 }
 
+impl QueryInner {
+    #[zenoh_macros::internal]
+    fn empty() -> Self {
+        QueryInner {
+            key_expr: KeyExpr::dummy(),
+            parameters: Parameters::empty(),
+            qid: 0,
+            zid: ZenohIdProto::default(),
+            primitives: Arc::new(DummyPrimitives),
+        }
+    }
+}
+
 impl Drop for QueryInner {
     fn drop(&mut self) {
         self.primitives.send_response_final(ResponseFinal {
@@ -202,9 +217,9 @@ impl Query {
 
     /// Constructs an empty Query without payload, nor attachment referencing the same inner query.
     #[zenoh_macros::internal]
-    pub unsafe fn empty(&self) -> Self {
+    pub unsafe fn empty() -> Self {
         Query {
-            inner: self.inner.clone(),
+            inner: Arc::new(QueryInner::empty()),
             eid: 0,
             value: None,
             attachment: None,

zenoh/src/api/sample.rs

@@ -432,9 +432,9 @@ impl Sample {
 
     /// Constructs an uninitialized empty Sample.
     #[zenoh_macros::internal]
-    pub unsafe fn empty() -> Self {
+    pub fn empty() -> Self {
         Sample {
-            key_expr: KeyExpr::from_str_unchecked(""),
+            key_expr: KeyExpr::dummy(),
             payload: ZBytes::new(),
             kind: SampleKind::Put,
             encoding: Encoding::default(),

zenoh/src/api/session.rs

@@ -2113,7 +2113,7 @@ impl SessionInner {
         drop(state);
         let mut sample = info.clone().into_sample(
             // SAFETY: the keyexpr is valid
-            unsafe { KeyExpr::from_str_unchecked("dummy") },
+            KeyExpr::dummy(),
             payload,
             #[cfg(feature = "unstable")]
             reliability,

zenoh/tests/keyexpr.rs

@@ -0,0 +1,25 @@
+//
+// Copyright (c) 2025 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <[email protected]>
+//
+#[cfg(feature = "internal")]
+use zenoh::key_expr::KeyExpr;
+
+#[test]
+#[cfg(feature = "internal")]
+fn keyexpr_test_dummy() {
+    let dummy_expr = KeyExpr::dummy();
+    assert!(dummy_expr.is_dummy());
+
+    let non_dummy_expr = KeyExpr::try_from("dummy").unwrap();
+    assert!(!non_dummy_expr.is_dummy());
+}