reuse JNINative

Author: milyin

prebindgen-ext/src/jni/jni_kotlin_ext.rs

@@ -295,8 +295,11 @@ import kotlin.concurrent.write
  * destructor entry points without a matching `#[prebindgen]` fn use
  * [close]. The auto-generated wrappers in `JNIWrappers.kt` are the
  * only callers that need to know which mode applies.
+ *
+ * Marked `open` so the hand-maintained `JNI*.kt` typed-handle classes
+ * can subclass for type safety while inheriting the lock contract.
  */
-public class NativeHandle(initial: Long) {
+public open class NativeHandle(initial: Long) {
     private val lock = ReentrantReadWriteLock()
 
     /** Volatile so [peek] is atomic on 32-bit JVMs and observes the
@@ -410,7 +413,21 @@ fn render_jni_wrappers_source(
         out.push_str(&format!("import {}\n", imp));
     }
     out.push('\n');
-    out.push_str(&body);
+    // Wrap the wrappers in an `object` so the names don't collide with
+    // same-named methods on the hand-maintained JNI*.kt classes
+    // (`put`, `delete`, `close`, etc.). Callers use `JNIWrappers.put(...)`.
+    out.push_str("public object JNIWrappers {\n");
+    // Indent each emitted wrapper body by 4 spaces.
+    for line in body.lines() {
+        if line.is_empty() {
+            out.push('\n');
+        } else {
+            out.push_str("    ");
+            out.push_str(line);
+            out.push('\n');
+        }
+    }
+    out.push_str("}\n");
     out
 }
 

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNIAdvancedPublisher.kt

@@ -18,36 +18,31 @@ import io.zenoh.exceptions.ZError
 import io.zenoh.jni.callbacks.JNIMatchingListenerCallback
 import io.zenoh.jni.callbacks.JNIOnCloseCallback
 
-/**
- * Adapter class for a native Zenoh AdvancedPublisher.
- *
- * @param initialPtr Raw pointer to the underlying native AdvancedPublisher.
- */
-public class JNIAdvancedPublisher(initialPtr: Long) {
-    private val handle = NativeHandle(initialPtr)
+/** Typed [NativeHandle] for a native Zenoh `AdvancedPublisher`. */
+public class JNIAdvancedPublisher(initialPtr: Long) : NativeHandle(initialPtr) {
 
     @Throws(ZError::class)
-    fun put(payload: ByteArray, encoding: JNIEncoding, attachment: ByteArray?) = handle.withPtr { ptr ->
+    fun put(payload: ByteArray, encoding: JNIEncoding, attachment: ByteArray?) = withPtr { ptr ->
         putViaJNI(ptr, payload, encoding, attachment)
     }
 
     @Throws(ZError::class)
-    fun delete(attachment: ByteArray?) = handle.withPtr { ptr ->
+    fun delete(attachment: ByteArray?) = withPtr { ptr ->
         deleteViaJNI(ptr, attachment)
     }
 
     @Throws(ZError::class)
     fun declareMatchingListener(callback: JNIMatchingListenerCallback, onClose: JNIOnCloseCallback): JNIMatchingListener =
-        handle.withPtr { ptr -> JNIMatchingListener(declareMatchingListenerViaJNI(ptr, callback, onClose)) }
+        withPtr { ptr -> JNIMatchingListener(declareMatchingListenerViaJNI(ptr, callback, onClose)) }
 
     @Throws(ZError::class)
     fun declareBackgroundMatchingListener(callback: JNIMatchingListenerCallback, onClose: JNIOnCloseCallback) =
-        handle.withPtr { ptr -> declareBackgroundMatchingListenerViaJNI(ptr, callback, onClose) }
+        withPtr { ptr -> declareBackgroundMatchingListenerViaJNI(ptr, callback, onClose) }
 
     @Throws(ZError::class)
-    fun getMatchingStatus(): Boolean = handle.withPtr { ptr -> getMatchingStatusViaJNI(ptr) }
+    fun getMatchingStatus(): Boolean = withPtr { ptr -> getMatchingStatusViaJNI(ptr) }
 
-    fun close() = handle.close(::freePtrViaJNI)
+    fun close() = close { freePtrViaJNI(it) }
 
     @Throws(ZError::class)
     private external fun putViaJNI(

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNIAdvancedSubscriber.kt

@@ -16,23 +16,18 @@ package io.zenoh.jni
 
 import io.zenoh.exceptions.ZError
 import io.zenoh.jni.callbacks.JNIOnCloseCallback
-import io.zenoh.jni.callbacks.JNISampleMissListenerCallback
 import io.zenoh.jni.callbacks.JNISampleCallback
+import io.zenoh.jni.callbacks.JNISampleMissListenerCallback
 
-/**
- * Adapter class for a native Zenoh AdvancedSubscriber.
- *
- * @param initialPtr Raw pointer to the underlying native AdvancedSubscriber.
- */
-public class JNIAdvancedSubscriber(initialPtr: Long) {
-    private val handle = NativeHandle(initialPtr)
+/** Typed [NativeHandle] for a native Zenoh `AdvancedSubscriber`. */
+public class JNIAdvancedSubscriber(initialPtr: Long) : NativeHandle(initialPtr) {
 
     @Throws(ZError::class)
     fun declareDetectPublishersSubscriber(
         history: Boolean,
         callback: JNISampleCallback,
         onClose: JNIOnCloseCallback,
-    ): JNISubscriber = handle.withPtr { ptr ->
+    ): JNISubscriber = withPtr { ptr ->
         JNISubscriber(declareDetectPublishersSubscriberViaJNI(ptr, history, callback, onClose))
     }
 
@@ -41,27 +36,27 @@ public class JNIAdvancedSubscriber(initialPtr: Long) {
         history: Boolean,
         callback: JNISampleCallback,
         onClose: JNIOnCloseCallback,
-    ) = handle.withPtr { ptr ->
+    ) = withPtr { ptr ->
         declareBackgroundDetectPublishersSubscriberViaJNI(ptr, history, callback, onClose)
     }
 
     @Throws(ZError::class)
     fun declareSampleMissListener(
         callback: JNISampleMissListenerCallback,
         onClose: JNIOnCloseCallback,
-    ): JNISampleMissListener = handle.withPtr { ptr ->
+    ): JNISampleMissListener = withPtr { ptr ->
         JNISampleMissListener(declareSampleMissListenerViaJNI(ptr, callback, onClose))
     }
 
     @Throws(ZError::class)
     fun declareBackgroundSampleMissListener(
         callback: JNISampleMissListenerCallback,
         onClose: JNIOnCloseCallback,
-    ) = handle.withPtr { ptr ->
+    ) = withPtr { ptr ->
         declareBackgroundSampleMissListenerViaJNI(ptr, callback, onClose)
     }
 
-    fun close() = handle.close(::freePtrViaJNI)
+    fun close() = close { freePtrViaJNI(it) }
 
     @Throws(ZError::class)
     private external fun declareDetectPublishersSubscriberViaJNI(

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNIConfig.kt

@@ -17,17 +17,14 @@ package io.zenoh.jni
 import io.zenoh.ZenohLoad
 import io.zenoh.exceptions.ZError
 
-/** Adapter for the native Zenoh config. */
-public class JNIConfig(initialPtr: Long) {
-    private val handle = NativeHandle(initialPtr)
-
-    /**
-     * Pointer accessor for callers that need to pass the raw pointer
-     * to another JNI method (e.g. `openSessionViaJNI(config.ptr)`).
-     * Throws if the config has already been closed.
-     */
-    internal val ptr: Long
-        get() = handle.withPtr { it }
+/**
+ * Typed [NativeHandle] for a native Zenoh `Config`. The `load*` and
+ * `freePtrViaJNI` entry points aren't generated from zenoh-flat (the
+ * Rust side is hand-written in `zenoh-jni/src/config.rs`), so the
+ * companion's external funs stay here; instance methods that ARE
+ * `#[prebindgen]` would delegate to [JNIWrappers].
+ */
+public class JNIConfig(initialPtr: Long) : NativeHandle(initialPtr) {
 
     companion object {
 
@@ -71,16 +68,16 @@ public class JNIConfig(initialPtr: Long) {
         private external fun getJsonViaJNI(ptr: Long, key: String): String
     }
 
-    fun close() = handle.close { freePtrViaJNI(it) }
+    fun close() = close { freePtrViaJNI(it) }
 
     @Throws(ZError::class)
-    fun getId(): ByteArray = handle.withPtr { ptr -> getIdViaJNI(ptr) }
+    fun getId(): ByteArray = withPtr { ptr -> getIdViaJNI(ptr) }
 
     @Throws(ZError::class)
-    fun getJson(key: String): String = handle.withPtr { ptr -> getJsonViaJNI(ptr, key) }
+    fun getJson(key: String): String = withPtr { ptr -> getJsonViaJNI(ptr, key) }
 
     @Throws(ZError::class)
-    fun insertJson5(key: String, value: String) = handle.withPtr { ptr ->
+    fun insertJson5(key: String, value: String) = withPtr { ptr ->
         insertJson5ViaJNI(ptr, key, value)
     }
 }

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNIKeyExpr.kt

@@ -4,7 +4,7 @@
 // This program and the accompanying materials are made available under the
 // terms of the Eclipse Public License 2.0 which is available at
 // http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
-// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+// which is available at https://www.apache.org/legal/epl-2.0.
 //
 // SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 //
@@ -19,19 +19,13 @@ import io.zenoh.exceptions.ZError
 /**
  * Helpers for the key-expression JNI surface.
  *
- * The native side accepts `Any` for every key-expr parameter and
- * dispatches at runtime: a [Long] is treated as the
- * `Arc<KeyExpr<'static>>` registration handle, anything else
- * (a [String] in practice) is validated and converted to an owned
- * `KeyExpr<'static>`. Pass `handle ?: keyExprString` to native fns —
- * the `?:` operator picks the boxed [Long] when present, otherwise the
- * raw string.
- *
- * Functions that *return* a key-expression hand back a [Long] (the
- * Arc pointer); the canonical string is computed locally on the
- * Kotlin side. For [join] / [concat] the result string matches
- * Rust's `format!("{a}/{other}")` / `format!("{a}{other}")` since
- * the native validation is non-rewriting.
+ * Operations that have a `#[prebindgen]` counterpart in `zenoh-flat`
+ * (`try_from`, `autocanonize`, `intersects`, `includes`, `relation_to`,
+ * `join`, `concat`) delegate to the generator-emitted wrappers in
+ * [JNIWrappers]. The hand-written `dropKeyExprViaJNI` is retained as a
+ * dedicated free entry point — it doesn't appear as a `#[prebindgen]`
+ * fn because the consume semantic for a session-undeclare goes through
+ * `undeclare_key_expr` instead.
  */
 
 /**
@@ -42,36 +36,36 @@ import io.zenoh.exceptions.ZError
 fun keyExprArg(handle: Long?, str: String): Any = handle ?: str
 
 @Throws(ZError::class)
-fun keyExprTryFrom(keyExpr: String): String = JNINative.tryFromViaJNI(keyExpr)
+fun keyExprTryFrom(keyExpr: String): String = JNIWrappers.tryFrom(keyExpr)
 
 @Throws(ZError::class)
-fun keyExprAutocanonize(keyExpr: String): String = JNINative.autocanonizeViaJNI(keyExpr)
+fun keyExprAutocanonize(keyExpr: String): String = JNIWrappers.autocanonize(keyExpr)
 
 @Throws(ZError::class)
 fun keyExprIntersects(a: Long?, aStr: String, b: Long?, bStr: String): Boolean =
-    JNINative.intersectsViaJNI(keyExprArg(a, aStr), keyExprArg(b, bStr))
+    JNIWrappers.intersects(keyExprArg(a, aStr), keyExprArg(b, bStr))
 
 @Throws(ZError::class)
 fun keyExprIncludes(a: Long?, aStr: String, b: Long?, bStr: String): Boolean =
-    JNINative.includesViaJNI(keyExprArg(a, aStr), keyExprArg(b, bStr))
+    JNIWrappers.includes(keyExprArg(a, aStr), keyExprArg(b, bStr))
 
 @Throws(ZError::class)
 fun keyExprRelationTo(a: Long?, aStr: String, b: Long?, bStr: String): Int =
-    JNINative.relationToViaJNI(keyExprArg(a, aStr), keyExprArg(b, bStr))
+    JNIWrappers.relationTo(keyExprArg(a, aStr), keyExprArg(b, bStr))
 
 /** Result of a join/concat: `(handle, canonicalString)`. */
 data class KeyExprResult(val handle: Long, val string: String)
 
 @Throws(ZError::class)
 fun keyExprJoin(a: Long?, aStr: String, other: String): KeyExprResult {
-    val handle = JNINative.joinViaJNI(keyExprArg(a, aStr), other)
+    val handle = JNIWrappers.join(keyExprArg(a, aStr), other).peek()
     // Match Rust's `KeyExpr::join` formatting: "{self}/{other}".
     return KeyExprResult(handle, "$aStr/$other")
 }
 
 @Throws(ZError::class)
 fun keyExprConcat(a: Long?, aStr: String, other: String): KeyExprResult {
-    val handle = JNINative.concatViaJNI(keyExprArg(a, aStr), other)
+    val handle = JNIWrappers.concat(keyExprArg(a, aStr), other).peek()
     // Match Rust's `KeyExpr::concat` formatting: "{self}{other}".
     return KeyExprResult(handle, "$aStr$other")
 }

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNILivelinessToken.kt

@@ -14,11 +14,8 @@
 
 package io.zenoh.jni
 
-/** Adapter class for a native Zenoh LivelinessToken. */
-public class JNILivelinessToken(initialPtr: Long) {
-    private val handle = NativeHandle(initialPtr)
-
-    fun undeclare() = handle.close(::undeclareViaJNI)
-
+/** Typed [NativeHandle] for a native Zenoh `LivelinessToken`. */
+public class JNILivelinessToken(initialPtr: Long) : NativeHandle(initialPtr) {
+    fun undeclare() = close { undeclareViaJNI(it) }
     private external fun undeclareViaJNI(ptr: Long)
 }

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNIMatchingListener.kt

@@ -14,11 +14,8 @@
 
 package io.zenoh.jni
 
-/** Adapter class for a native Zenoh MatchingListener. */
-public class JNIMatchingListener(initialPtr: Long) {
-    private val handle = NativeHandle(initialPtr)
-
-    fun close() = handle.close(::freePtrViaJNI)
-
+/** Typed [NativeHandle] for a native Zenoh `MatchingListener`. */
+public class JNIMatchingListener(initialPtr: Long) : NativeHandle(initialPtr) {
+    fun close() = close { freePtrViaJNI(it) }
     private external fun freePtrViaJNI(ptr: Long)
 }

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNIPublisher.kt

@@ -15,32 +15,25 @@
 package io.zenoh.jni
 
 import io.zenoh.exceptions.ZError
-import io.zenoh.jni.JNINative.deletePublisherViaJNI
-import io.zenoh.jni.JNINative.putPublisherViaJNI
 
 /**
- * Adapter class for a native Zenoh publisher. Uses primitive types for put/delete.
- *
- * @param initialPtr Raw pointer to the underlying native Publisher.
+ * Typed [NativeHandle] for a native Zenoh `Publisher`. `put` and
+ * `delete` delegate to the generator-emitted wrappers in
+ * [JNIWrappers]; `freePtrViaJNI` is hand-written in Rust (the
+ * by-value `drop_publisher` shape isn't a `#[prebindgen]` fn because
+ * `Publisher` is not `Clone`), so [close] keeps the direct call.
  */
-public class JNIPublisher(initialPtr: Long) {
-    private val handle = NativeHandle(initialPtr)
+public class JNIPublisher(initialPtr: Long) : NativeHandle(initialPtr) {
 
     @Throws(ZError::class)
-    fun put(payload: ByteArray, encoding: JNIEncoding, attachment: ByteArray?) = handle.withPtr { ptr ->
-        putPublisherViaJNI(ptr, payload, encoding, attachment)
-    }
+    fun put(payload: ByteArray, encoding: JNIEncoding, attachment: ByteArray?) =
+        JNIWrappers.putPublisher(this, payload, encoding, attachment)
 
     @Throws(ZError::class)
-    fun delete(attachment: ByteArray?) = handle.withPtr { ptr ->
-        deletePublisherViaJNI(ptr, attachment)
-    }
+    fun delete(attachment: ByteArray?) =
+        JNIWrappers.deletePublisher(this, attachment)
 
-    fun close() = handle.close(::freePtrViaJNI)
+    fun close() = close { freePtrViaJNI(it) }
 
-    // freePtrViaJNI is hand-written in zenoh-jni/src/publisher.rs because
-    // the auto-generated `opaque_arc_input` convention clones the outer
-    // Arc on borrow and drops the clone on exit, so the master Arc is
-    // released via this dedicated entry point.
     private external fun freePtrViaJNI(ptr: Long)
 }

zenoh-jni-runtime/src/commonMain/kotlin/io/zenoh/jni/JNIQuerier.kt

@@ -18,9 +18,13 @@ import io.zenoh.exceptions.ZError
 import io.zenoh.jni.callbacks.JNIGetCallback
 import io.zenoh.jni.callbacks.JNIOnCloseCallback
 
-/** Adapter class for a native Zenoh querier. */
-public class JNIQuerier(initialPtr: Long) {
-    private val handle = NativeHandle(initialPtr)
+/**
+ * Typed [NativeHandle] for a native Zenoh `Querier`. `get` and
+ * `freePtrViaJNI` are hand-written JNI entry points (not in
+ * `zenoh-flat`), so they stay as `external fun` methods routed through
+ * the inherited [withPtr].
+ */
+public class JNIQuerier(initialPtr: Long) : NativeHandle(initialPtr) {
 
     @Throws(ZError::class)
     fun get(
@@ -32,7 +36,7 @@ public class JNIQuerier(initialPtr: Long) {
         attachmentBytes: ByteArray?,
         payload: ByteArray?,
         encoding: JNIEncoding?,
-    ) = handle.withPtr { ptr ->
+    ) = withPtr { ptr ->
         getViaJNI(ptr, keyExprArg(keyExprHandle, keyExprString), parameters, callback, onClose, attachmentBytes, payload, encoding)
     }
 
@@ -50,5 +54,5 @@ public class JNIQuerier(initialPtr: Long) {
 
     private external fun freePtrViaJNI(ptr: Long)
 
-    fun close() = handle.close(::freePtrViaJNI)
+    fun close() = close { freePtrViaJNI(it) }
 }