common type binding method

milyin · milyin · commit d9b1c86bffee · 2026-04-25T18:37:05.000+02:00
diff --git a/zenoh-flat/src/jni_converter.rs b/zenoh-flat/src/jni_converter.rs
@@ -43,10 +43,14 @@
 //!     .throw_exception("crate::throw_exception")
 //!     .string_decoder("crate::utils::decode_string")
 //!     .byte_array_decoder("crate::utils::decode_byte_array")
-//!     .struct_decoder(
-//!         "KeyExpr",
-//!         "crate::key_expr::decode_jni_key_expr",
-//!         "JNIKeyExpr",
+//!     .type_binding(
+//!         TypeBinding::new("KeyExpr").kotlin("JNIKeyExpr").consume(
+//!             JniForm::new(
+//!                 "jni::objects::JObject",
+//!                 "JObject",
+//!                 ArgDecode::env_ref_mut("crate::key_expr::decode_jni_key_expr"),
+//!             ),
+//!         ),
 //!     )
 //!     .build();
 //! source
@@ -111,6 +115,36 @@ pub enum ArgDecode {
     ConsumeArc,
 }
 
+impl ArgDecode {
+    /// `ArgDecode::Pure` from a path string (parsed lazily).
+    pub fn pure(path: impl AsRef<str>) -> Self {
+        ArgDecode::Pure(syn::parse_str(path.as_ref()).expect("invalid ArgDecode::pure path"))
+    }
+
+    /// `ArgDecode::EnvRefMut` from a path string.
+    pub fn env_ref_mut(path: impl AsRef<str>) -> Self {
+        ArgDecode::EnvRefMut(
+            syn::parse_str(path.as_ref()).expect("invalid ArgDecode::env_ref_mut path"),
+        )
+    }
+
+    /// `ArgDecode::EnvByVal` from a path string.
+    pub fn env_by_val(path: impl AsRef<str>) -> Self {
+        ArgDecode::EnvByVal(
+            syn::parse_str(path.as_ref()).expect("invalid ArgDecode::env_by_val path"),
+        )
+    }
+}
+
+impl ReturnEncode {
+    /// `ReturnEncode::Wrapper` from a path string.
+    pub fn wrapper(path: impl AsRef<str>) -> Self {
+        ReturnEncode::Wrapper(
+            syn::parse_str(path.as_ref()).expect("invalid ReturnEncode::wrapper path"),
+        )
+    }
+}
+
 /// Clonable closure that produces a TokenStream from the JNI input ident.
 #[derive(Clone)]
 pub struct InlineFn(Arc<dyn Fn(&syn::Ident) -> TokenStream + Send + Sync>);
@@ -444,62 +478,13 @@ impl Builder {
         self
     }
 
-    /// Register a decoder for an enum type. Equivalent to:
-    /// ```ignore
-    /// .type_binding(TypeBinding::new(name)
-    ///     .consume(JniForm::new("jni::sys::jint", "Int", ArgDecode::Pure(<path>))))
-    /// ```
-    pub fn enum_decoder(
-        mut self,
-        type_name: impl Into<String>,
-        decoder: impl AsRef<str>,
-    ) -> Self {
-        let name = type_name.into();
-        let p: syn::Path =
-            syn::parse_str(decoder.as_ref()).expect("invalid enum_decoder path");
-        let binding = self
-            .types
-            .entry(name.clone())
-            .or_insert_with(|| TypeBinding::new(name));
-        binding.consume = Some(JniForm::new(
-            "jni::sys::jint",
-            "Int",
-            ArgDecode::Pure(p),
-        ));
-        self
-    }
-
-    /// Register a decoder for a struct parameter passed across JNI as a plain
-    /// `JObject` (typically a Kotlin data class). The decoder must have
-    /// signature `fn(&mut JNIEnv, &JObject) -> ZResult<T>`. `kotlin_type` is
-    /// the Kotlin type name (FQN if out-of-package, bare otherwise).
-    pub fn struct_decoder(
-        mut self,
-        type_name: impl Into<String>,
-        decoder: impl AsRef<str>,
-        kotlin_type: impl Into<String>,
-    ) -> Self {
-        let name = type_name.into();
-        let kt = kotlin_type.into();
-        let p: syn::Path =
-            syn::parse_str(decoder.as_ref()).expect("invalid struct_decoder path");
-        let binding = self
-            .types
-            .entry(name.clone())
-            .or_insert_with(|| TypeBinding::new(name));
-        binding.kotlin_type = Some(kt);
-        binding.consume = Some(JniForm::new(
-            "jni::objects::JObject",
-            "JObject",
-            ArgDecode::EnvRefMut(p),
-        ));
-        self
-    }
-
     /// Register a decoder for an `impl Fn(T) + Send + Sync + 'static` callback
     /// parameter. `element_type_name` is the last path segment of `T`
     /// (e.g. `"Sample"`, `"Query"`, `"Reply"`). The decoder must have
     /// signature `fn(&mut JNIEnv, JObject) -> ZResult<impl Fn(T) + Send + Sync + 'static>`.
+    /// Callbacks have a fundamentally different shape (a closure-builder, not
+    /// a value decoder) so they are registered separately from
+    /// [`Builder::type_binding`].
     pub fn callback_decoder(
         mut self,
         element_type_name: impl Into<String>,
@@ -515,56 +500,6 @@ impl Builder {
         self
     }
 
-    /// Register a return-type wrapper for `ZResult<T>` where `T`'s
-    /// last-segment name equals `type_name`. `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>,
-        kotlin_type: impl Into<String>,
-    ) -> Self {
-        let name = type_name.into();
-        let kt = kotlin_type.into();
-        let wrap: syn::Path =
-            syn::parse_str(wrap_fn.as_ref()).expect("invalid return_wrapper wrap_fn path");
-        let mut form = ReturnForm::new(jni_type, ReturnEncode::Wrapper(wrap), default_expr);
-        form.kotlin_jni_type = Some(kt);
-        let binding = self
-            .types
-            .entry(name.clone())
-            .or_insert_with(|| TypeBinding::new(name));
-        binding.returns = Some(form);
-        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>,
-        kotlin_type: impl Into<String>,
-    ) -> Self {
-        let name = element_type_name.into();
-        let kt = kotlin_type.into();
-        let wrap: syn::Path =
-            syn::parse_str(wrap_fn.as_ref()).expect("invalid return_wrapper_vec wrap_fn path");
-        let mut form = ReturnForm::new(jni_type, ReturnEncode::Wrapper(wrap), default_expr);
-        form.kotlin_jni_type = Some(kt);
-        let binding = self
-            .types
-            .entry(name.clone())
-            .or_insert_with(|| TypeBinding::new(name));
-        binding.returns_vec = Some(form);
-        self
-    }
-
     /// Enable Kotlin-side prototype generation. `path` is where the `.kt`
     /// file will be written when [`JniConverter::write_kotlin`] is called.
     pub fn kotlin_output(mut self, path: impl Into<PathBuf>) -> Self {
diff --git a/zenoh-jni/build.rs b/zenoh-jni/build.rs
@@ -1,5 +1,17 @@
 use itertools::Itertools;
-use zenoh_flat::jni_converter::{ArgDecode, JniForm, TypeBinding};
+use zenoh_flat::jni_converter::{ArgDecode, JniForm, ReturnEncode, ReturnForm, TypeBinding};
+
+fn enum_binding(name: &str, decoder: &str) -> TypeBinding {
+    TypeBinding::new(name).consume(JniForm::new("jni::sys::jint", "Int", ArgDecode::pure(decoder)))
+}
+
+fn jobject_consume(name: &str, decoder: &str, kotlin: &str) -> TypeBinding {
+    TypeBinding::new(name).kotlin(kotlin).consume(JniForm::new(
+        "jni::objects::JObject",
+        "JObject",
+        ArgDecode::env_ref_mut(decoder),
+    ))
+}
 
 fn main() {
     let source = prebindgen::Source::new(zenoh_flat::PREBINDGEN_OUT_DIR);
@@ -19,15 +31,6 @@ fn main() {
         .kotlin_class("JNISessionNative")
         .kotlin_throws("io.zenoh.exceptions.ZError")
         .kotlin_init("io.zenoh.ZenohLoad")
-        .enum_decoder(
-            "CongestionControl",
-            "crate::utils::decode_congestion_control",
-        )
-        .enum_decoder("Priority", "crate::utils::decode_priority")
-        .enum_decoder("Reliability", "crate::utils::decode_reliability")
-        .enum_decoder("QueryTarget", "crate::utils::decode_query_target")
-        .enum_decoder("ConsolidationMode", "crate::utils::decode_consolidation")
-        .enum_decoder("ReplyKeyExpr", "crate::utils::decode_reply_key_expr")
         .callback_decoder(
             "Sample",
             "crate::sample_callback::process_kotlin_sample_callback",
@@ -48,6 +51,24 @@ fn main() {
             "crate::sample_callback::process_kotlin_on_close_callback",
             "io.zenoh.jni.callbacks.JNIOnCloseCallback",
         )
+        .type_binding(enum_binding(
+            "CongestionControl",
+            "crate::utils::decode_congestion_control",
+        ))
+        .type_binding(enum_binding("Priority", "crate::utils::decode_priority"))
+        .type_binding(enum_binding("Reliability", "crate::utils::decode_reliability"))
+        .type_binding(enum_binding(
+            "QueryTarget",
+            "crate::utils::decode_query_target",
+        ))
+        .type_binding(enum_binding(
+            "ConsolidationMode",
+            "crate::utils::decode_consolidation",
+        ))
+        .type_binding(enum_binding(
+            "ReplyKeyExpr",
+            "crate::utils::decode_reply_key_expr",
+        ))
         // KeyExpr by-value: the JNI side passes `Arc::into_raw(Arc::new(KeyExpr))`
         // as a raw pointer; the wrapper reconstructs the Arc, clones the inner
         // KeyExpr, and drops the Arc at end of scope. The full path is required
@@ -62,24 +83,29 @@ fn main() {
                 .pointer_param(true),
             ),
         )
-        .struct_decoder(
+        .type_binding(jobject_consume(
             "Encoding",
             "crate::utils::decode_jni_encoding",
             "JNIEncoding",
-        )
-        .return_wrapper(
-            "ZenohId",
-            "jni::sys::jbyteArray",
-            "crate::zenoh_id::zenoh_id_to_byte_array",
-            "jni::objects::JByteArray::default().as_raw()",
-            "ByteArray",
-        )
-        .return_wrapper_vec(
-            "ZenohId",
-            "jni::sys::jobject",
-            "crate::zenoh_id::zenoh_ids_to_java_list",
-            "jni::objects::JObject::default().as_raw()",
-            "List<ByteArray>",
+        ))
+        .type_binding(
+            TypeBinding::new("ZenohId")
+                .returns(
+                    ReturnForm::new(
+                        "jni::sys::jbyteArray",
+                        ReturnEncode::wrapper("crate::zenoh_id::zenoh_id_to_byte_array"),
+                        "jni::objects::JByteArray::default().as_raw()",
+                    )
+                    .kotlin("ByteArray"),
+                )
+                .returns_vec(
+                    ReturnForm::new(
+                        "jni::sys::jobject",
+                        ReturnEncode::wrapper("crate::zenoh_id::zenoh_ids_to_java_list"),
+                        "jni::objects::JObject::default().as_raw()",
+                    )
+                    .kotlin("List<ByteArray>"),
+                ),
         )
         .build();
 
