id functions in flat

Author: milyin

zenoh-flat/src/jni_converter.rs

@@ -60,6 +60,22 @@ pub struct Builder {
     /// the raw pointer via `Arc::from_raw`) instead of borrowed. Used for
     /// close/undeclare-style functions that invalidate their handle.
     consume_args: HashMap<String, HashSet<String>>,
+    /// Return-type wrappers keyed by the last-segment name of `T` in
+    /// `ZResult<T>`. Applies when `T` is a plain (non-`Vec`) type.
+    return_wrappers: HashMap<String, ReturnWrapper>,
+    /// Return-type wrappers keyed by the element type name of `Vec<T>` in
+    /// `ZResult<Vec<T>>`.
+    return_wrappers_vec: HashMap<String, ReturnWrapper>,
+}
+
+/// Describes how to render a `ZResult<T>` return value into a JNI-compatible
+/// output value. Registered via [`Builder::return_wrapper`] /
+/// [`Builder::return_wrapper_vec`].
+#[derive(Clone)]
+pub(crate) struct ReturnWrapper {
+    jni_type: syn::Type,
+    wrap_fn: syn::Path,
+    default_expr: syn::Expr,
 }
 
 impl Default for Builder {
@@ -78,6 +94,8 @@ impl Default for Builder {
             enum_decoders: HashMap::new(),
             callback_decoders: HashMap::new(),
             consume_args: HashMap::new(),
+            return_wrappers: HashMap::new(),
+            return_wrappers_vec: HashMap::new(),
         }
     }
 }
@@ -188,6 +206,37 @@ impl Builder {
         self
     }
 
+    /// Register a return-type wrapper for `ZResult<T>` where `T`'s
+    /// last-segment name equals `type_name`. `jni_type` is the generated
+    /// `extern "C"` return type. `wrap_fn` must have signature
+    /// `fn(&mut JNIEnv, T) -> ZResult<jni_type>`. `default_expr` is the value
+    /// returned on error (before the exception is thrown on the JVM side).
+    pub fn return_wrapper(
+        mut self,
+        type_name: impl Into<String>,
+        jni_type: impl AsRef<str>,
+        wrap_fn: impl AsRef<str>,
+        default_expr: impl AsRef<str>,
+    ) -> Self {
+        self.return_wrappers
+            .insert(type_name.into(), parse_return_wrapper(jni_type, wrap_fn, default_expr));
+        self
+    }
+
+    /// Like [`Builder::return_wrapper`] but applies when `T` is `Vec<E>`
+    /// with `E`'s last-segment name equal to `element_type_name`.
+    pub fn return_wrapper_vec(
+        mut self,
+        element_type_name: impl Into<String>,
+        jni_type: impl AsRef<str>,
+        wrap_fn: impl AsRef<str>,
+        default_expr: impl AsRef<str>,
+    ) -> Self {
+        self.return_wrappers_vec
+            .insert(element_type_name.into(), parse_return_wrapper(jni_type, wrap_fn, default_expr));
+        self
+    }
+
     /// Mark a specific argument of a source function as consuming: the
     /// generated wrapper will take ownership of the raw pointer via
     /// `Arc::from_raw` (dropping the Arc at end of scope), rather than
@@ -428,6 +477,37 @@ impl JniConverter {
                     });
                     call_args.push(quote! { #name });
                 }
+                ArgKind::OptionEncoding => {
+                    let decoder = self
+                        .cfg
+                        .encoding_decoder
+                        .as_ref()
+                        .expect("encoding_decoder not configured");
+                    let id_ident = format_ident!("{}_id", name);
+                    let schema_ident = format_ident!("{}_schema", name);
+                    jni_params.push(quote! { #id_ident: jni::sys::jint });
+                    jni_params.push(quote! { #schema_ident: jni::objects::JString });
+                    prelude.push(quote! {
+                        let #name = Some(#decoder(&mut env, #id_ident, &#schema_ident)?);
+                    });
+                    call_args.push(quote! { #name });
+                }
+                ArgKind::OptionString => {
+                    let decoder = self
+                        .cfg
+                        .string_decoder
+                        .as_ref()
+                        .expect("string_decoder not configured");
+                    jni_params.push(quote! { #name: jni::objects::JString });
+                    prelude.push(quote! {
+                        let #name = if !#name.is_null() {
+                            Some(#decoder(&mut env, &#name)?)
+                        } else {
+                            None
+                        };
+                    });
+                    call_args.push(quote! { #name });
+                }
                 ArgKind::Unsupported => panic!(
                     "unsupported parameter type `{}` for `{}` at {loc}",
                     ty.to_token_stream(),
@@ -453,6 +533,18 @@ impl JniConverter {
                         quote! { () },
                         quote! { #zresult<()> },
                     )
+                } else if let Some(wrapper) = self.lookup_return_wrapper(&inner) {
+                    let ReturnWrapper {
+                        jni_type,
+                        wrap_fn,
+                        default_expr,
+                    } = wrapper;
+                    (
+                        quote! { #jni_type },
+                        quote! { #wrap_fn(&mut env, __result) },
+                        quote! { #default_expr },
+                        quote! { #zresult<#jni_type> },
+                    )
                 } else {
                     (
                         quote! { *const #inner },
@@ -497,6 +589,23 @@ impl JniConverter {
         syn::parse2(tokens).expect("generated JNI wrapper must parse")
     }
 
+    fn lookup_return_wrapper(&self, ty: &syn::Type) -> Option<ReturnWrapper> {
+        let syn::Type::Path(tp) = ty else { return None };
+        let seg = tp.path.segments.last()?;
+        let name = seg.ident.to_string();
+        if name == "Vec" {
+            let syn::PathArguments::AngleBracketed(args) = &seg.arguments else {
+                return None;
+            };
+            let syn::GenericArgument::Type(elem) = args.args.first()? else {
+                return None;
+            };
+            let elem_name = type_last_segment(elem)?;
+            return self.cfg.return_wrappers_vec.get(&elem_name).cloned();
+        }
+        self.cfg.return_wrappers.get(&name).cloned()
+    }
+
     fn classify_arg(&self, ty: &syn::Type) -> ArgKind {
         match ty {
             syn::Type::Reference(r) if r.mutability.is_none() => {
@@ -537,6 +646,16 @@ impl JniConverter {
                 if name == "Option" && is_option_of_vec_u8(last) {
                     return ArgKind::OptionVecU8;
                 }
+                if name == "Option" {
+                    if let Some(inner) = option_inner_type_name(last) {
+                        if inner == "String" {
+                            return ArgKind::OptionString;
+                        }
+                        if inner == "Encoding" {
+                            return ArgKind::OptionEncoding;
+                        }
+                    }
+                }
                 if name == "Vec" && is_vec_of_u8(last) {
                     return ArgKind::VecU8;
                 }
@@ -564,12 +683,31 @@ enum ArgKind {
     VecU8,
     /// `Encoding` → `(jint id, JString schema)` pair via `encoding_decoder`.
     Encoding,
+    /// `Option<Encoding>` → `(jint id, JString schema)` pair via `encoding_decoder`,
+    /// wrapped in `Some(_)`. Semantic gating on payload presence is the
+    /// callee's responsibility.
+    OptionEncoding,
+    /// `Option<String>` → nullable `JString`.
+    OptionString,
     /// `impl Fn(T) + Send + Sync + 'static` → `(JObject callback, JObject on_close)`
     /// pair decoded via a callback decoder registered for `T`.
     Callback(syn::Path),
     Unsupported,
 }
 
+fn parse_return_wrapper(
+    jni_type: impl AsRef<str>,
+    wrap_fn: impl AsRef<str>,
+    default_expr: impl AsRef<str>,
+) -> ReturnWrapper {
+    ReturnWrapper {
+        jni_type: syn::parse_str(jni_type.as_ref()).expect("invalid return wrapper jni_type"),
+        wrap_fn: syn::parse_str(wrap_fn.as_ref()).expect("invalid return wrapper wrap_fn path"),
+        default_expr: syn::parse_str(default_expr.as_ref())
+            .expect("invalid return wrapper default_expr"),
+    }
+}
+
 fn type_last_segment(ty: &syn::Type) -> Option<String> {
     let syn::Type::Path(tp) = ty else { return None };
     tp.path.segments.last().map(|s| s.ident.to_string())
@@ -593,6 +731,18 @@ fn extract_fn_single_arg_type_name(
     None
 }
 
+/// Return the last-segment name of the single generic argument of an
+/// `Option<...>` path segment, if any (e.g. `Option<String>` → `Some("String")`).
+fn option_inner_type_name(seg: &syn::PathSegment) -> Option<String> {
+    let syn::PathArguments::AngleBracketed(args) = &seg.arguments else {
+        return None;
+    };
+    let syn::GenericArgument::Type(inner) = args.args.first()? else {
+        return None;
+    };
+    type_last_segment(inner)
+}
+
 /// Check whether an `Option<...>` path segment wraps exactly `Vec<u8>`.
 fn is_option_of_vec_u8(seg: &syn::PathSegment) -> bool {
     let syn::PathArguments::AngleBracketed(args) = &seg.arguments else {

zenoh-flat/src/session.rs

@@ -23,7 +23,7 @@ use zenoh::{
     query::{ConsolidationMode, Query, QueryTarget, Queryable, Querier, Reply, ReplyKeyExpr, Selector},
     sample::Sample,
     qos::{CongestionControl, Priority, Reliability},
-    session::Session,
+    session::{Session, ZenohId},
     Wait,
 };
 
@@ -204,27 +204,31 @@ pub fn declare_queryable(
 ///
 /// Each [`Reply`] received from the network is delivered to the `callback`.
 /// `selector_params` is appended to the `key_expr` to form the query selector
-/// (pass `String::new()` for no parameters). `payload` and `encoding` are
-/// coupled: if a payload is given, encoding is attached; if no payload is
-/// given, encoding is ignored.
+/// (pass `None` for no parameters). `payload` and `encoding` are coupled:
+/// if a payload is given, encoding is attached; if no payload is given,
+/// encoding is ignored.
+///
+/// Parameter order matches the JNI calling convention so the wrapper can be
+/// generated by `zenoh_flat::jni_converter` without reordering.
+#[prebindgen_proc_macro::prebindgen("jni")]
 pub fn get(
     session: &Session,
     key_expr: KeyExpr<'static>,
-    selector_params: String,
+    selector_params: Option<String>,
     callback: impl Fn(Reply) + Send + Sync + 'static,
+    timeout: Duration,
     query_target: QueryTarget,
     consolidation: ConsolidationMode,
+    attachment: Option<Vec<u8>>,
+    payload: Option<Vec<u8>>,
+    encoding: Option<Encoding>,
     congestion_control: CongestionControl,
     priority: Priority,
     express: bool,
-    timeout: Duration,
     reply_key_expr: ReplyKeyExpr,
-    payload: Option<Vec<u8>>,
-    encoding: Option<Encoding>,
-    attachment: Option<Vec<u8>>,
 ) -> ZResult<()> {
     let key_expr_string = key_expr.to_string();
-    let selector = Selector::owned(&key_expr, selector_params);
+    let selector = Selector::owned(&key_expr, selector_params.unwrap_or_default());
     let mut get_builder = session
         .get(selector)
         .callback(callback)
@@ -329,6 +333,24 @@ pub fn delete(
         })
 }
 
+/// Return the Zenoh ID of the session.
+#[prebindgen_proc_macro::prebindgen("jni")]
+pub fn get_zid(session: &Session) -> ZResult<ZenohId> {
+    Ok(session.info().zid().wait())
+}
+
+/// Return the Zenoh IDs of the peers connected to this session.
+#[prebindgen_proc_macro::prebindgen("jni")]
+pub fn get_peers_zid(session: &Session) -> ZResult<Vec<ZenohId>> {
+    Ok(session.info().peers_zid().wait().collect())
+}
+
+/// Return the Zenoh IDs of the routers connected to this session.
+#[prebindgen_proc_macro::prebindgen("jni")]
+pub fn get_routers_zid(session: &Session) -> ZResult<Vec<ZenohId>> {
+    Ok(session.info().routers_zid().wait().collect())
+}
+
 /// Close a Zenoh session using a reference to the session.
 #[prebindgen_proc_macro::prebindgen("jni")]
 pub fn close_session(session: &Session) -> ZResult<()> {

zenoh-jni/build.rs

@@ -25,6 +25,18 @@ fn main() {
         .callback_decoder("Reply", "crate::sample_callback::process_kotlin_reply_callback")
         .consume_arg("close_session", "session")
         .consume_arg("undeclare_key_expr", "key_expr")
+        .return_wrapper(
+            "ZenohId",
+            "jni::sys::jbyteArray",
+            "crate::zenoh_id::zenoh_id_to_byte_array",
+            "jni::objects::JByteArray::default().as_raw()",
+        )
+        .return_wrapper_vec(
+            "ZenohId",
+            "jni::sys::jobject",
+            "crate::zenoh_id::zenoh_ids_to_java_list",
+            "jni::objects::JObject::default().as_raw()",
+        )
         .build();
 
     source