recursive expamd demo

Author: milyin

zenoh-flat-jni/build.rs

@@ -203,6 +203,12 @@ fn main() {
         .package("sample")
         .enum_class(pq!(SampleKind))
         .ptr_class(pq!(ZSample))
+        // Canonical INPUT: a ZSample is built from (key_expr, payload, encoding)
+        // via z_sample_new. Because those params are themselves ptr_class types
+        // with their own canonical inputs, a `ZSample` param expands RECURSIVELY:
+        // key_expr → (String|handle selector), payload → ByteArray, encoding →
+        // String — all flattened into the consuming fn's signature.
+        .ptr_class_input(pq!(z_sample_new))
         // Canonical output: the full sample decomposed in ONE crossing. Each
         // record is unwrapped per its return type's canonical output —
         // z_sample_key_expr → (ZKeyExpr handle, String); payload/attachment →
@@ -248,6 +254,9 @@ fn main() {
         .fun(pq!(z_query_reply_success))
         .fun(pq!(z_query_reply_error))
         .fun(pq!(z_query_reply_delete))
+        // Recursive-input demo: `sample: ZSample` expands via z_sample_new into
+        // (key_expr String|handle, payload ByteArray, encoding String).
+        .fun(pq!(z_query_reply_sample))
         .fun_accessor(pq!(z_query_keyexpr))
         .fun_accessor(pq!(z_query_parameters))
         .fun_accessor(pq!(z_query_payload))

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

@@ -126,6 +126,7 @@ internal object JNINative {
     external fun zQueryPayload(q: Long, errorSink: Any): Long
     external fun zQueryReplyDelete(query: Long, keyExprSel: Int, keyExpr0: String?, keyExpr1: Long, timestampNtp64: Long?, attachment: ByteArray?, express: Boolean?, errorSink: Any)
     external fun zQueryReplyError(query: Long, payload: ByteArray, encoding: String?, errorSink: Any)
+    external fun zQueryReplySample(query: Long, sampleKeyExprSel: Int, sampleKeyExpr0: String?, sampleKeyExpr1: Long, samplePayload: ByteArray, sampleEncoding: String, errorSink: Any)
     external fun zQueryReplySuccess(query: Long, keyExprSel: Int, keyExpr0: String?, keyExpr1: Long, payload: ByteArray, encoding: String?, timestampNtp64: Long?, attachment: ByteArray?, express: Boolean?, errorSink: Any)
     external fun zReplyErrorEncoding(r: Long, errorSink: Any): Long
     external fun zReplyErrorPayload(r: Long, errorSink: Any): Long

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

@@ -82,6 +82,30 @@ public fun zQueryReplyDelete(query: ZQuery, keyExprSel: Int, keyExpr0: String?,
     if (__cap_failed) return onError(__cap_je, (__cap_ze0 ?: ""))
 }
 
+public fun zQueryReplySample(query: ZQuery, sampleKeyExprSel: Int, sampleKeyExpr0: String?, sampleKeyExpr1: ZKeyExpr?, samplePayload: ByteArray, sampleEncoding: String, onError: (String?, String) -> Unit = { __de_je, __de_z0 -> throw ZException(__de_je ?: __de_z0) }) {
+    if (query.ptr == 0L) { onError("Operation on a closed native handle.", ""); return }
+    if (sampleKeyExpr1 != null && sampleKeyExpr1.ptr == 0L) { onError("Operation on a closed native handle.", ""); return }
+    var __cap_failed = false
+    var __cap_je: String? = null
+    var __cap_ze0: String? = null
+    val __cap = { __je: String?, __ze0: String? -> __cap_failed = true; __cap_je = __je; __cap_ze0 = __ze0 }
+    run {
+    val __locks = ArrayList<NativeHandle>()
+    __locks.add(query)
+    sampleKeyExpr1?.let { __locks.add(it) }
+    withSortedHandleLocks(__locks) {
+    val query_ptr = query.ptr
+    val sampleKeyExpr1_ptr = sampleKeyExpr1?.ptr ?: 0L
+    try {
+    JNINative.zQueryReplySample(query_ptr, sampleKeyExprSel, sampleKeyExpr0, sampleKeyExpr1_ptr, samplePayload, sampleEncoding, __cap)
+    } finally {
+    sampleKeyExpr1?.let { it.ptr = 0L }
+    }
+    }
+    }
+    if (__cap_failed) return onError(__cap_je, (__cap_ze0 ?: ""))
+}
+
 public fun zQueryKeyexpr(q: ZQuery, onError: (String?) -> ZKeyExpr = { __de_je -> throw ZException(__de_je) }): ZKeyExpr {
     if (q.ptr == 0L) return onError("Operation on a closed native handle.")
     var __cap_failed = false