query structure

Author: milyin

prebindgen-ext/src/jni/jni_ext.rs

@@ -4151,6 +4151,27 @@ fn struct_input_body(
             let java_path = handle_field_fqn(ext, h).replace('.', "/");
             let sig = format!("L{};", java_path);
             let tmp_ident = format_ident!("__{}_jobj", fname_ident);
+            // Struct fields are owned, so a non-`Option` handle field owns
+            // its native object: decode by consuming (`Box::from_raw` → owned
+            // `T`), mirroring `struct_output_body`'s `Box::into_raw`. The
+            // borrow converter would yield `OwnedObject<T>`, which can't
+            // populate an owned field. `Option<_>` handle fields keep the
+            // niche-aware converter (jlong 0 ⇒ `None`).
+            let field_ty = &field.ty;
+            let field_is_option = matches!(
+                field_ty,
+                syn::Type::Path(p) if p.path.segments.last()
+                    .map(|s| s.ident == "Option").unwrap_or(false)
+            );
+            let decode = if field_is_option {
+                quote! { let #fname_ident = #field_conv(env, &#raw_ident)?; }
+            } else {
+                quote! {
+                    let #fname_ident: #field_ty = unsafe {
+                        *std::boxed::Box::from_raw(#raw_ident as *mut #field_ty)
+                    };
+                }
+            };
             field_preludes.push(quote! {
                 let #tmp_ident: jni::objects::JObject = env.get_field(v, #camel, #sig)
                     .and_then(|val| val.l())
@@ -4162,7 +4183,7 @@ fn struct_input_body(
                         .and_then(|val| val.j())
                         .map_err(|e| <__JniErr as ::core::convert::From<String>>::from(format!(#err_prefix, e)))?
                 };
-                let #fname_ident = #field_conv(env, &#raw_ident)?;
+                #decode
             });
             field_init.push(quote!(#fname_ident));
             continue;

zenoh-flat-jni/build.rs

@@ -200,10 +200,13 @@ fn main() {
         .package("query")
         .ptr_class(pq!(ZQueryable))
         .ptr_class(pq!(ZQuerier))
+        .enum_class(pq!(ReplyKeyExpr))
         .ptr_class(pq!(ZQuery))
         .class_fun(pq!(z_query_reply_success))
         .class_fun(pq!(z_query_reply_error))
         .class_fun(pq!(z_query_reply_delete))
+        .class_fun(pq!(query_take))
+        .data_class(pq!(Query))
         .into_sources(
             pq!(ZBytes),
             [

zenoh-flat-jni/generated-kotlin/io/zenoh/jni/JNINative.kt

@@ -13,6 +13,7 @@ import io.zenoh.jni.config.ZZenohId
 import io.zenoh.jni.keyexpr.KeyExpr
 import io.zenoh.jni.keyexpr.SetIntersectionLevel
 import io.zenoh.jni.keyexpr.ZKeyExpr
+import io.zenoh.jni.query.Query
 import io.zenoh.jni.scouting.ZScout
 
 internal object JNINative {
@@ -80,6 +81,7 @@ internal object JNINative {
     external fun keyexprJoin(a: Any, b: String): KeyExpr
     external fun keyexprRelationTo(a: Any, b: Any): Int
     external fun keyexprTryFrom(s: String): KeyExpr
+    external fun queryTake(query: Long): Query
     external fun scout(whatami: Int, config: Long, callback: HelloCallback, onClose: Callback): Long
     external fun tryInitZenohLogsFromEnv()
     external fun zConfigDefault(): Long

zenoh-flat-jni/generated-kotlin/io/zenoh/jni/query/Query.kt

@@ -0,0 +1,23 @@
+// Auto-generated by JniExt — do not edit by hand.
+package io.zenoh.jni.query
+
+import io.zenoh.jni.bytes.Encoding
+import io.zenoh.jni.bytes.ZBytes
+import io.zenoh.jni.keyexpr.KeyExpr
+
+public data class Query(
+    val keyExpr: KeyExpr,
+    val parameters: String,
+    val payload: ZBytes?,
+    val encoding: Encoding?,
+    val attachment: ZBytes?,
+    val acceptsReplies: ReplyKeyExpr,
+    val query: ZQuery,
+) : AutoCloseable {
+    override fun close() {
+        query.close()
+    }
+
+    public companion object {
+    }
+}

zenoh-flat-jni/generated-kotlin/io/zenoh/jni/query/ReplyKeyExpr.kt

@@ -0,0 +1,13 @@
+// Auto-generated by JniExt — do not edit by hand.
+package io.zenoh.jni.query
+
+/** JVM-side surface for the native Rust `ReplyKeyExpr` enum. */
+public enum class ReplyKeyExpr(public val value: Int) {
+    ANY(0),
+    MATCHING_QUERY(1);
+
+    public companion object {
+        @JvmStatic
+        public fun fromInt(value: Int): ReplyKeyExpr = entries.first { it.value == value }
+    }
+}

zenoh-flat-jni/generated-kotlin/io/zenoh/jni/query/ZQuery.kt

@@ -154,6 +154,19 @@ public class ZQuery(initialPtr: Long) : AutoCloseable {
         }
     }
 
+    @Throws(JniBindingError::class)
+    public fun queryTake(): Query {
+        synchronized(this) {
+            val query_ptr = this.ptr
+            if (query_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
+            return try {
+                JNINative.queryTake(query_ptr)
+            } finally {
+                ptr = 0L
+            }
+        }
+    }
+
     public companion object {
         @JvmStatic
         external fun freePtr(ptr: Long)

zenoh-flat-jni/src/lib.rs

@@ -6,6 +6,7 @@ use zenoh_flat::SetIntersectionLevel;
 use zenoh_flat::CongestionControl;
 use zenoh_flat::Priority;
 use zenoh_flat::Reliability;
+use zenoh_flat::ReplyKeyExpr;
 
 // Generated by build.rs into OUT_DIR.
 include!(concat!(env!("OUT_DIR"), "/zenoh_flat_jni.rs"));

zenoh-flat/src/keyexpr/keyexpr.rs

@@ -29,6 +29,7 @@ impl From<zenoh::key_expr::SetIntersectionLevel> for SetIntersectionLevel {
 }
 
 #[prebindgen]
+#[derive(Clone)]
 pub struct KeyExpr {
     pub key_expr_string: String,
     pub key_expr_native: Option<ZKeyExpr>,

zenoh-flat/src/query/mod.rs

@@ -1,3 +1,7 @@
+pub(crate) mod query;
+pub(crate) mod reply_key_expr;
 pub(crate) mod z_query;
 
+pub use query::*;
+pub use reply_key_expr::*;
 pub use z_query::*;

zenoh-flat/src/query/query.rs

@@ -0,0 +1,36 @@
+use crate::{Encoding, KeyExpr, ReplyKeyExpr, ZBytes, ZQuery};
+use prebindgen_proc_macro::prebindgen;
+
+/// Data-class twin of [`ZQuery`]. Carries decoded query fields plus the
+/// live [`ZQuery`] handle, which the binding uses to reply.
+#[prebindgen]
+pub struct Query {
+    pub key_expr: KeyExpr,
+    pub parameters: String,
+    pub payload: Option<ZBytes>,
+    pub encoding: Option<Encoding>,
+    pub attachment: Option<ZBytes>,
+    pub accepts_replies: ReplyKeyExpr,
+    pub query: ZQuery,
+}
+
+impl From<ZQuery> for Query {
+    fn from(q: ZQuery) -> Self {
+        Query {
+            key_expr: KeyExpr::from(q.key_expr().clone()),
+            parameters: q.parameters().to_string(),
+            payload: q.payload().map(|p| ZBytes::from(p.clone())),
+            encoding: q.encoding().map(Encoding::from),
+            attachment: q.attachment().map(|a| ZBytes::from(a.clone())),
+            accepts_replies: q.accepts_replies().into(),
+            query: q,
+        }
+    }
+}
+
+/// Consume an opaque [`ZQuery`] handle and repack it into the decoded
+/// [`Query`] data class (re-embedding the same native query for replies).
+#[prebindgen]
+pub fn query_take(query: ZQuery) -> Query {
+    Query::from(query)
+}