valur type handling fix

Author: milyin

prebindgen-ext/src/jni/jni_ext.rs

@@ -16,6 +16,7 @@ import io.zenoh.jni.callbacks.ZSampleCallback
 import io.zenoh.jni.config.WhatAmI
 import io.zenoh.jni.config.ZConfig
 import io.zenoh.jni.config.ZZenohId
+import io.zenoh.jni.config.ZenohId
 import io.zenoh.jni.keyexpr.KeyExpr
 import io.zenoh.jni.keyexpr.SetIntersectionLevel
 import io.zenoh.jni.keyexpr.ZKeyExpr
@@ -194,14 +195,14 @@ internal object JNINative {
     external fun zQueryReplyDelete(query: Long, keyExpr: Any, timestampNtp64: Long?, attachment: Any?, express: Boolean)
     external fun zQueryReplyError(query: Long, payload: Any, encoding: Any)
     external fun zQueryReplySuccess(query: Long, keyExpr: Any, payload: Any, encoding: Any, timestampNtp64: Long?, attachment: Any?, express: Boolean)
-    external fun zReplyErrorEncoding(r: Long): Long
-    external fun zReplyErrorPayload(r: Long): Long
+    external fun zReplyErrorEncoding(r: Long): Long?
+    external fun zReplyErrorPayload(r: Long): Long?
     external fun zReplyExpand(r: Long): Reply
     external fun zReplyIsOk(r: Long): Boolean
     external fun zReplyReplierEid(r: Long): Int
-    external fun zReplyReplierZid(r: Long): Long
-    external fun zReplySample(r: Long): Long
-    external fun zSampleAttachment(s: Long): Long
+    external fun zReplyReplierZid(r: Long): Long?
+    external fun zReplySample(r: Long): Long?
+    external fun zSampleAttachment(s: Long): Long?
     external fun zSampleCongestionControl(s: Long): Int
     external fun zSampleEncoding(s: Long): Long
     external fun zSampleExpand(s: Long): Sample
@@ -210,7 +211,7 @@ internal object JNINative {
     external fun zSampleKind(s: Long): Int
     external fun zSamplePayload(s: Long): Long
     external fun zSamplePriority(s: Long): Int
-    external fun zSampleTimestamp(s: Long): Long
+    external fun zSampleTimestamp(s: Long): Long?
     external fun zScout(whatami: Int, config: Long, callback: ZHelloCallback, onClose: Callback): Long
     external fun zSessionDeclareKeyexpr(session: Long, keyExpr: String): Long
     external fun zSessionDeclarePublisher(session: Long, keyExpr: Any, congestionControl: Int, priority: Int, express: Boolean, reliability: Int): Long

prebindgen-ext/src/jni/jni_kotlin_ext.rs

@@ -36,7 +36,7 @@ public class ZReply(initialPtr: Long) : AutoCloseable {
         synchronized(this) {
             val r_ptr = this.ptr
             if (r_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return ZZenohId(JNINative.zReplyReplierZid(r_ptr))
+            return JNINative.zReplyReplierZid(r_ptr)?.let { ZZenohId(it) }
         }
     }
 
@@ -63,7 +63,7 @@ public class ZReply(initialPtr: Long) : AutoCloseable {
         synchronized(this) {
             val r_ptr = this.ptr
             if (r_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return ZSample(JNINative.zReplySample(r_ptr))
+            return JNINative.zReplySample(r_ptr)?.let { ZSample(it) }
         }
     }
 
@@ -72,7 +72,7 @@ public class ZReply(initialPtr: Long) : AutoCloseable {
         synchronized(this) {
             val r_ptr = this.ptr
             if (r_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return ZZBytes(JNINative.zReplyErrorPayload(r_ptr))
+            return JNINative.zReplyErrorPayload(r_ptr)?.let { ZZBytes(it) }
         }
     }
 
@@ -81,7 +81,7 @@ public class ZReply(initialPtr: Long) : AutoCloseable {
         synchronized(this) {
             val r_ptr = this.ptr
             if (r_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return ZEncoding(JNINative.zReplyErrorEncoding(r_ptr))
+            return JNINative.zReplyErrorEncoding(r_ptr)?.let { ZEncoding(it) }
         }
     }
 

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

@@ -74,7 +74,7 @@ public class ZSample(initialPtr: Long) : AutoCloseable {
         synchronized(this) {
             val s_ptr = this.ptr
             if (s_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return ZTimestamp(JNINative.zSampleTimestamp(s_ptr))
+            return JNINative.zSampleTimestamp(s_ptr)?.let { ZTimestamp(it) }
         }
     }
 
@@ -110,7 +110,7 @@ public class ZSample(initialPtr: Long) : AutoCloseable {
         synchronized(this) {
             val s_ptr = this.ptr
             if (s_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return ZZBytes(JNINative.zSampleAttachment(s_ptr))
+            return JNINative.zSampleAttachment(s_ptr)?.let { ZZBytes(it) }
         }
     }
 

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

@@ -14,6 +14,7 @@ import io.zenoh.jni.callbacks.ZQueryCallback
 import io.zenoh.jni.callbacks.ZReplyCallback
 import io.zenoh.jni.callbacks.ZSampleCallback
 import io.zenoh.jni.config.ZConfig
+import io.zenoh.jni.config.ZenohId
 import io.zenoh.jni.keyexpr.ZKeyExpr
 import io.zenoh.jni.liveliness.ZLivelinessToken
 import io.zenoh.jni.pubsub.ZPublisher
@@ -386,29 +387,29 @@ public class ZSession(initialPtr: Long) : AutoCloseable {
     }
 
     @Throws(JniBindingError::class)
-    public fun zSessionZid(): ByteArray {
+    public fun zSessionZid(): ZenohId {
         synchronized(this) {
             val session_ptr = this.ptr
             if (session_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return JNINative.zSessionZid(session_ptr)
+            return ZenohId(JNINative.zSessionZid(session_ptr))
         }
     }
 
     @Throws(JniBindingError::class)
-    public fun zSessionPeersZid(): List<ByteArray> {
+    public fun zSessionPeersZid(): List<ZenohId> {
         synchronized(this) {
             val session_ptr = this.ptr
             if (session_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return JNINative.zSessionPeersZid(session_ptr)
+            return JNINative.zSessionPeersZid(session_ptr).map { ZenohId(it) }
         }
     }
 
     @Throws(JniBindingError::class)
-    public fun zSessionRoutersZid(): List<ByteArray> {
+    public fun zSessionRoutersZid(): List<ZenohId> {
         synchronized(this) {
             val session_ptr = this.ptr
             if (session_ptr == 0L) throw JniBindingError("Operation on a closed native handle.")
-            return JNINative.zSessionRoutersZid(session_ptr)
+            return JNINative.zSessionRoutersZid(session_ptr).map { ZenohId(it) }
         }
     }
 

zenoh-flat-jni/generated-kotlin/io/zenoh/jni/sample/ZSample.kt

@@ -2,7 +2,7 @@ use crate::util::OnceDrop;
 use crate::{
     into_native, CongestionControl, ConsolidationMode, Encoding, Error, KeyExpr, Priority, Query,
     QueryTarget, Reliability, Reply, ReplyKeyExpr, Sample, ZBytes, ZConfig, ZEncoding, ZKeyExpr,
-    ZPublisher, ZQuerier, ZQuery, ZQueryable, ZReply, ZSample, ZSession, ZSubscriber,
+    ZPublisher, ZQuerier, ZQuery, ZQueryable, ZReply, ZSample, ZSession, ZSubscriber, ZenohId,
 };
 use prebindgen_proc_macro::prebindgen;
 use std::time::Duration;
@@ -300,32 +300,27 @@ pub fn session_get(
     )
 }
 
-// Zid accessors return raw little-endian id bytes (Kotlin `ByteArray` /
-// `List<ByteArray>`); the public layer wraps them into `ZenohId`. Returning the
-// `ZenohId` value class directly would be ambiguous in a `Vec` — value classes
-// box in generic position but erase to their inner elsewhere — so bytes keep
-// the FFI surface unambiguous and match the existing public bridging.
+// Zid accessors return the value-class `ZenohId` directly. With the unified
+// newtype projection, value classes ride the same fold-and-wrap machinery as
+// opaque handles: the generated Kotlin surface is `ZenohId` / `List<ZenohId>`,
+// each value erased to its inner `[B` over the wire and wrapped on the Kotlin
+// side, with no raw-bytes hop visible in the FFI surface.
 #[prebindgen]
-pub fn z_session_zid(session: &ZSession) -> Vec<u8> {
-    session.info().zid().wait().to_le_bytes().to_vec()
+pub fn z_session_zid(session: &ZSession) -> ZenohId {
+    ZenohId::from(session.info().zid().wait())
 }
 
 #[prebindgen]
-pub fn z_session_peers_zid(session: &ZSession) -> Vec<Vec<u8>> {
-    session
-        .info()
-        .peers_zid()
-        .wait()
-        .map(|z| z.to_le_bytes().to_vec())
-        .collect()
+pub fn z_session_peers_zid(session: &ZSession) -> Vec<ZenohId> {
+    session.info().peers_zid().wait().map(ZenohId::from).collect()
 }
 
 #[prebindgen]
-pub fn z_session_routers_zid(session: &ZSession) -> Vec<Vec<u8>> {
+pub fn z_session_routers_zid(session: &ZSession) -> Vec<ZenohId> {
     session
         .info()
         .routers_zid()
         .wait()
-        .map(|z| z.to_le_bytes().to_vec())
+        .map(ZenohId::from)
         .collect()
 }

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

@@ -249,16 +249,16 @@ internal class JNISession(internal val zSession: ZSession) {
 
     @Throws(ZError::class)
     fun zid(): ZenohId = wrapJNIExceptionAsZError {
-        ZenohId(io.zenoh.jni.config.ZenohId(zSession.zSessionZid()))
+        ZenohId(zSession.zSessionZid())
     }
 
     @Throws(ZError::class)
     fun peersZid(): List<ZenohId> = wrapJNIExceptionAsZError {
-        zSession.zSessionPeersZid().map { ZenohId(io.zenoh.jni.config.ZenohId(it)) }
+        zSession.zSessionPeersZid().map { ZenohId(it) }
     }
 
     @Throws(ZError::class)
     fun routersZid(): List<ZenohId> = wrapJNIExceptionAsZError {
-        zSession.zSessionRoutersZid().map { ZenohId(io.zenoh.jni.config.ZenohId(it)) }
+        zSession.zSessionRoutersZid().map { ZenohId(it) }
     }
 }