sample attachment accessor

Author: milyin

zenoh-flat-jni/build.rs

@@ -109,6 +109,13 @@ fn main() {
         // per-call `zZbytesFromVec` crossing. (No identity arm: the SDK never
         // holds a ZZBytes handle for these.)
         .constructor(pq!(z_zbytes_from_vec))
+        // Combined ACCESSOR for ZZBytes (output expansion): an `Option<&ZZBytes>`
+        // return (e.g. z_sample_attachment) is decomposed into its bytes
+        // (`z_zbytes_to_bytes` → ByteArray) and delivered to a builder lambda —
+        // no transient handle + `close()`. No identity record (the SDK ZBytes
+        // holds the ByteArray, not the native handle).
+        .combined_accessor(pq!(ZZBytes))
+        .combined_accessor_record(pq!(z_zbytes_to_bytes))
         .ptr_class(pq!(ZEncoding))
         .package_fun(pq!(z_encoding_id))
         .package_fun(pq!(z_encoding_schema))
@@ -177,6 +184,14 @@ fn main() {
         .ptr_class(pq!(ZTimestamp))
         .package_fun(pq!(z_timestamp_ntp64))
         .package_fun(pq!(z_timestamp_id))
+        // Combined ACCESSOR for ZTimestamp (output expansion): an
+        // `Option<&ZTimestamp>` return (z_sample_timestamp) is decomposed into
+        // its NTP64 value (`z_timestamp_ntp64` → i64 → boxed Long) and delivered
+        // to a builder lambda — no second `zTimestampNtp64` crossing, no
+        // transient handle. No identity record (zenoh-java's TimeStamp keeps the
+        // Long, not the native handle).
+        .combined_accessor(pq!(ZTimestamp))
+        .combined_accessor_record(pq!(z_timestamp_ntp64))
         .package("sample")
         .enum_class(pq!(SampleKind))
         .ptr_class(pq!(ZSample))
@@ -186,10 +201,12 @@ fn main() {
         .package_fun(pq!(z_sample_encoding))
         .package_fun(pq!(z_sample_kind))
         .package_fun(pq!(z_sample_timestamp))
+        .expand_output() // Option<&ZTimestamp> → builder (Long ntp64) → R?
         .package_fun(pq!(z_sample_express))
         .package_fun(pq!(z_sample_priority))
         .package_fun(pq!(z_sample_congestion_control))
         .package_fun(pq!(z_sample_attachment))
+        .expand_output() // Option<&ZZBytes> → builder (ByteArray) → R?
         .package("pubsub")
         .ptr_class(pq!(ZPublisher))
         .package_fun(pq!(z_publisher_put))

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

@@ -25,7 +25,6 @@ import io.zenoh.jni.sample.SampleKind
 import io.zenoh.jni.sample.ZSample
 import io.zenoh.jni.scouting.ZScout
 import io.zenoh.jni.session.ZSession
-import io.zenoh.jni.time.ZTimestamp
 
 internal object JNINative {
     external fun initAndroidLogs(filter: String, errorSink: Any)
@@ -132,15 +131,15 @@ internal object JNINative {
     external fun zReplyReplierEid(r: Long, errorSink: Any): Int
     external fun zReplyReplierZid(r: Long, errorSink: Any): ByteArray?
     external fun zReplySample(r: Long, errorSink: Any): Long
-    external fun zSampleAttachment(s: Long, errorSink: Any): Long
+    external fun zSampleAttachment(s: Long, build: Any, errorSink: Any): Any?
     external fun zSampleCongestionControl(s: Long, errorSink: Any): Int
     external fun zSampleEncoding(s: Long, errorSink: Any): Long
     external fun zSampleExpress(s: Long, errorSink: Any): Boolean
     external fun zSampleKeyExpr(s: Long, build: Any, errorSink: Any): Any?
     external fun zSampleKind(s: Long, errorSink: Any): Int
     external fun zSamplePayload(s: Long, errorSink: Any): Long
     external fun zSamplePriority(s: Long, errorSink: Any): Int
-    external fun zSampleTimestamp(s: Long, errorSink: Any): Long
+    external fun zSampleTimestamp(s: Long, build: Any, errorSink: Any): Any?
     external fun zScout(whatami: Int, config: Long, callback: ZHelloCallback, onClose: Callback, errorSink: Any): Long
     external fun zSessionDeclareKeyexpr(session: Long, keyExpr: String, errorSink: Any): Long
     external fun zSessionDeclarePublisher(session: Long, keyExprSel: Int, keyExpr0: String?, keyExpr1: Long, congestionControl: Int?, priority: Int?, express: Boolean?, reliability: Int?, errorSink: Any): Long

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

@@ -11,7 +11,6 @@ import io.zenoh.jni.qos.CongestionControl
 import io.zenoh.jni.qos.Priority
 import io.zenoh.jni.sample.SampleKind
 import io.zenoh.jni.sample.ZSample
-import io.zenoh.jni.time.ZTimestamp
 import io.zenoh.jni.withSortedHandleLocks
 import io.zenoh.jni.JNINative
 
@@ -64,13 +63,14 @@ public fun zSampleKind(s: ZSample): SampleKind {
     return __ret
 }
 
-public fun zSampleTimestamp(s: ZSample): ZTimestamp? {
+@Suppress("UNCHECKED_CAST")
+public fun <R> zSampleTimestamp(s: ZSample, build: (Long) -> R): R? {
     val __err = ErrorHolder()
     val __sink = ErrorSink { __m -> __err.message = __m }
     val __ret = withSortedHandleLocks(s) {
     val s_ptr = s.ptr
     if (s_ptr == 0L) throw ZException("Operation on a closed native handle.")
-    JNINative.zSampleTimestamp(s_ptr, __sink).let { if (it == 0L) null else ZTimestamp(it) }
+    (JNINative.zSampleTimestamp(s_ptr, build, __sink) as R?)
     }
     __err.message?.let { throw ZException(it) }
     return __ret
@@ -112,13 +112,14 @@ public fun zSampleCongestionControl(s: ZSample): CongestionControl {
     return __ret
 }
 
-public fun zSampleAttachment(s: ZSample): ZZBytes? {
+@Suppress("UNCHECKED_CAST")
+public fun <R> zSampleAttachment(s: ZSample, build: (ByteArray) -> R): R? {
     val __err = ErrorHolder()
     val __sink = ErrorSink { __m -> __err.message = __m }
     val __ret = withSortedHandleLocks(s) {
     val s_ptr = s.ptr
     if (s_ptr == 0L) throw ZException("Operation on a closed native handle.")
-    JNINative.zSampleAttachment(s_ptr, __sink).let { if (it == 0L) null else ZZBytes(it) }
+    (JNINative.zSampleAttachment(s_ptr, build, __sink) as R?)
     }
     __err.message?.let { throw ZException(it) }
     return __ret

zenoh-java/src/commonMain/kotlin/io/zenoh/sample/Sample.kt

@@ -66,19 +66,19 @@ data class Sample(
             val payload = ZBytes.fromHandle(io.zenoh.jni.sample.zSamplePayload(zs))
             val encoding = Encoding.fromHandle(io.zenoh.jni.sample.zSampleEncoding(zs))
             val kind = io.zenoh.jni.sample.zSampleKind(zs).toPublic()
-            val timestamp = io.zenoh.jni.sample.zSampleTimestamp(zs)?.let { ts ->
-                try {
-                    TimeStamp(io.zenoh.jni.time.zTimestampNtp64(ts))
-                } finally {
-                    ts.close()
-                }
-            }
+            // Output expansion: the native layer extracts the timestamp's NTP64
+            // value and delivers it to this builder in one JNI crossing (no
+            // second `zTimestampNtp64` call, no transient handle to close).
+            // Returns null when the sample has no timestamp.
+            val timestamp = io.zenoh.jni.sample.zSampleTimestamp(zs) { ntp64 -> TimeStamp(ntp64) }
             val qos = QoS(
                 CongestionControl.fromJni(io.zenoh.jni.sample.zSampleCongestionControl(zs)),
                 Priority.fromJni(io.zenoh.jni.sample.zSamplePriority(zs)),
                 io.zenoh.jni.sample.zSampleExpress(zs)
             )
-            val attachment = io.zenoh.jni.sample.zSampleAttachment(zs)?.let { ZBytes.fromHandle(it) }
+            // Output expansion: the attachment bytes are delivered directly to
+            // this builder (no transient handle + `close()`); null when absent.
+            val attachment = io.zenoh.jni.sample.zSampleAttachment(zs) { bytes -> ZBytes(bytes) }
             return Sample(keyExpr, payload, encoding, kind, timestamp, qos, attachment)
         }
     }

zenoh-java/src/jvmTest/java/io/zenoh/SubscriberTest.java

@@ -34,6 +34,7 @@
 import java.util.ArrayList;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
 @RunWith(JUnit4.class)
@@ -128,6 +129,27 @@ public void subscriber_sampleKeyExprDeliversHandleAndString() throws ZError {
         subscriber.close();
     }
 
+    /**
+     * Output (data) expansion, nullable path: a sample published without a
+     * timestamp / attachment exercises the `Option<&T>` "None ⇒ null result"
+     * branch of zSampleTimestamp / zSampleAttachment (builder skipped). The
+     * default session adds no timestamp, so both must come back null.
+     */
+    @Test
+    public void subscriber_sampleNullableFieldsAreNull() throws ZError {
+        var receivedSamples = new ArrayList<Sample>();
+        var subscriber = session.declareSubscriber(testKeyExpr, receivedSamples::add);
+
+        session.put(testKeyExpr, ZBytes.from("no-timestamp"));
+
+        assertEquals(1, receivedSamples.size());
+        Sample s = receivedSamples.get(0);
+        assertNull(s.getTimestamp());
+        assertNull(s.getAttachment());
+
+        subscriber.close();
+    }
+
     @Test
     public void subscriber_runsWithHandler() throws ZError {
         var handler = new QueueHandler<Sample>();