vec unfold

Author: milyin

zenoh-flat-jni/build.rs

@@ -304,8 +304,14 @@ fn main() {
         .expand(pq!(encoding)) // Option<&ZEncoding> ← String?
         .expand(pq!(attachment)) // Option<ZZBytes> ← ByteArray?
         .package_fun(pq!(z_session_zid))
+        // Output expansion (M4, Iterable): Vec<ZZenohId> → fold, each ZZenohId
+        // delivered WHOLE (its value_blob projection); caller owns the result
+        // collection. No combined accessor — the element crosses as the typed
+        // `ZZenohId` value class, matching the prior `List<ZZenohId>`.
         .package_fun(pq!(z_session_peers_zid))
+        .expand_output() // Vec<ZZenohId> → fun <A>(acc, fold: (A, ZZenohId) -> A): A
         .package_fun(pq!(z_session_routers_zid))
+        .expand_output()
         .package_fun(pq!(z_liveliness_declare_token))
         .expand(pq!(key_expr)) // ZKeyExpr (by-value) ← String | handle
         .package_fun(pq!(z_liveliness_get))

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

@@ -147,9 +147,9 @@ internal object JNINative {
     external fun zSessionDeclareSubscriber(session: Long, keyExprSel: Int, keyExpr0: String?, keyExpr1: Long, callback: ZSampleCallback, onClose: Callback, errorSink: Any): Long
     external fun zSessionDelete(session: Long, keyExprSel: Int, keyExpr0: String?, keyExpr1: Long, congestionControl: Int?, priority: Int?, express: Boolean?, attachment: ByteArray?, reliability: Int?, errorSink: Any)
     external fun zSessionGet(session: Long, keyExprSel: Int, keyExpr0: String?, keyExpr1: Long, parameters: String?, timeoutMs: Long?, target: Int?, consolidation: Int?, acceptReplies: Int?, congestionControl: Int?, priority: Int?, express: Boolean?, payload: ByteArray?, encoding: String?, attachment: ByteArray?, callback: ZReplyCallback, onClose: Callback, errorSink: Any)
-    external fun zSessionPeersZid(session: Long, errorSink: Any): List<ByteArray>
+    external fun zSessionPeersZid(session: Long, acc: Any?, fold: Any, errorSink: Any): Any?
     external fun zSessionPut(session: Long, keyExprSel: Int, keyExpr0: String?, keyExpr1: Long, payload: ByteArray, encoding: String?, congestionControl: Int?, priority: Int?, express: Boolean?, attachment: ByteArray?, reliability: Int?, errorSink: Any)
-    external fun zSessionRoutersZid(session: Long, errorSink: Any): List<ByteArray>
+    external fun zSessionRoutersZid(session: Long, acc: Any?, fold: Any, errorSink: Any): Any?
     external fun zSessionUndeclareKeyexpr(session: Long, keyExpr: Long, errorSink: Any)
     external fun zSessionZid(session: Long, errorSink: Any): ByteArray
     external fun zTimestampId(t: Long, errorSink: Any): ByteArray

zenoh-flat-jni/generated-kotlin/io/zenoh/jni/session/JNIsession.kt

@@ -230,25 +230,27 @@ public fun zSessionZid(session: ZSession): ZZenohId {
     return __ret
 }
 
-public fun zSessionPeersZid(session: ZSession): List<ZZenohId> {
+@Suppress("UNCHECKED_CAST")
+public fun <A> zSessionPeersZid(session: ZSession, acc: A, fold: (A, ZZenohId) -> A): A {
     val __err = ErrorHolder()
     val __sink = ErrorSink { __m -> __err.message = __m }
     val __ret = withSortedHandleLocks(session) {
     val session_ptr = session.ptr
     if (session_ptr == 0L) throw ZException("Operation on a closed native handle.")
-    JNINative.zSessionPeersZid(session_ptr, __sink).map { ZZenohId(it) }
+    (JNINative.zSessionPeersZid(session_ptr, acc, { __a: A, __raw: ByteArray -> fold(__a, ZZenohId(__raw)) }, __sink) as A)
     }
     __err.message?.let { throw ZException(it) }
     return __ret
 }
 
-public fun zSessionRoutersZid(session: ZSession): List<ZZenohId> {
+@Suppress("UNCHECKED_CAST")
+public fun <A> zSessionRoutersZid(session: ZSession, acc: A, fold: (A, ZZenohId) -> A): A {
     val __err = ErrorHolder()
     val __sink = ErrorSink { __m -> __err.message = __m }
     val __ret = withSortedHandleLocks(session) {
     val session_ptr = session.ptr
     if (session_ptr == 0L) throw ZException("Operation on a closed native handle.")
-    JNINative.zSessionRoutersZid(session_ptr, __sink).map { ZZenohId(it) }
+    (JNINative.zSessionRoutersZid(session_ptr, acc, { __a: A, __raw: ByteArray -> fold(__a, ZZenohId(__raw)) }, __sink) as A)
     }
     __err.message?.let { throw ZException(it) }
     return __ret

zenoh-java/src/commonMain/kotlin/io/zenoh/Session.kt

@@ -823,13 +823,24 @@ class Session private constructor(private val config: Config) : AutoCloseable {
     @Throws(ZError::class)
     internal fun getPeersId(): List<ZenohId> {
         val zSession = zSession ?: throw sessionClosedException
-        return wrapJNIExceptionAsZError { io.zenoh.jni.session.zSessionPeersZid(zSession).map { ZenohId(it) } }
+        // Output expansion (M4): the native side folds each ZZenohId into this
+        // accumulator in one pass — the caller owns the list (no intermediate
+        // List<ZZenohId>). `zid` is the typed ZZenohId value class.
+        return wrapJNIExceptionAsZError {
+            io.zenoh.jni.session.zSessionPeersZid(zSession, ArrayList<ZenohId>()) { list, zid ->
+                list.add(ZenohId(zid)); list
+            }
+        }
     }
 
     @Throws(ZError::class)
     internal fun getRoutersId(): List<ZenohId> {
         val zSession = zSession ?: throw sessionClosedException
-        return wrapJNIExceptionAsZError { io.zenoh.jni.session.zSessionRoutersZid(zSession).map { ZenohId(it) } }
+        return wrapJNIExceptionAsZError {
+            io.zenoh.jni.session.zSessionRoutersZid(zSession, ArrayList<ZenohId>()) { list, zid ->
+                list.add(ZenohId(zid)); list
+            }
+        }
     }
 
     /** Launches the session, returning the [Session] on success. */