Serialization feature

.gitignore

@@ -19,3 +19,4 @@
 /examples/build/
 /build/
 /.gradle/
+*/build/

examples/build.gradle.kts

@@ -14,6 +14,7 @@
 
 plugins {
     kotlin("jvm")
+    kotlin("plugin.serialization") version "1.9.0"
 }
 
 kotlin {
@@ -23,17 +24,28 @@ kotlin {
 dependencies {
     implementation(project(":zenoh-java"))
     implementation("commons-net:commons-net:3.9.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
+    implementation("info.picocli:picocli:4.7.4")
+    implementation("com.google.guava:guava:33.3.1-jre")
 }
 
 tasks {
     val examples = listOf(
+        "ZBytesExamples",
         "ZDelete",
         "ZGet",
+        "ZGetLiveliness",
+        "ZInfo",
+        "ZLiveliness",
+        "ZPing",
+        "ZPong",
         "ZPub",
         "ZPubThr",
         "ZPut",
         "ZQueryable",
+        "ZScout",
         "ZSub",
+        "ZSubLiveliness",
         "ZSubThr"
     )
 

examples/src/main/java/io/zenoh/Config.kt

@@ -0,0 +1,74 @@
+//
+// Copyright (c) 2023 ZettaScale Technology
+//
+// 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.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <[email protected]>
+//
+
+package io.zenoh
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.encodeToJsonElement
+import kotlin.io.path.Path
+
+@Serializable
+data class ConfigData(
+    @SerialName("connect") var connect: Connect? = null,
+    @SerialName("listen") var listen: Listen? = null,
+    @SerialName("mode") var mode: String? = null,
+    @SerialName("scouting") var scouting: Scouting? = null,
+)
+
+@Serializable
+data class Connect(
+    @SerialName("endpoints") var endpoints: List<String>
+)
+
+@Serializable
+data class Listen(
+    @SerialName("endpoints") var endpoints: List<String>
+)
+
+@Serializable
+data class Scouting(
+    @SerialName("multicast") var multicast: Multicast,
+)
+
+@Serializable
+data class Multicast(
+    @SerialName("enabled") var enabled: Boolean,
+)
+
+internal fun loadConfig(
+    emptyArgs: Boolean,
+    configFile: String?,
+    connectEndpoints: List<String>?,
+    listenEndpoints: List<String>?,
+    noMulticastScouting: Boolean?,
+    mode: String?
+): Config {
+    return if (emptyArgs) {
+        Config.loadDefault()
+    } else {
+        configFile?.let {
+            Config.fromFile(path = Path(it))
+        } ?: run {
+            val connect = connectEndpoints?.let {Connect(it)}
+            val listen = listenEndpoints?.let {Listen(it)}
+            val scouting = noMulticastScouting?.let { Scouting(Multicast(!it)) }
+            val configData = ConfigData(connect, listen, mode, scouting)
+            val jsonConfig = Json.encodeToJsonElement(configData).toString()
+            println(jsonConfig)
+            Config.fromJson(jsonConfig)
+        }
+    }
+}

examples/src/main/java/io/zenoh/QueueHandler.java

@@ -0,0 +1,33 @@
+package io.zenoh;
+
+import io.zenoh.handlers.Handler;
+
+import java.util.ArrayDeque;
+
+/**
+ * Sample handler for the sake of the examples.
+ *
+ * A custom handler can be implemented to handle incoming samples, queries or replies for
+ * subscribers, get operations, query operations or queryables.
+ *
+ * The example below shows a queue handler, in which an ArrayDeque is specified as the receiver type.
+ * The function handle will be called everytime an element of type T is received and in our example
+ * implementation, elements are simply enqueued into the queue, which can later be retrieved.
+ */
+class QueueHandler<T extends ZenohType> implements Handler<T, ArrayDeque<T>> {
+
+    final ArrayDeque<T> queue = new ArrayDeque<>();
+
+    @Override
+    public void handle(T t) {
+        queue.add(t);
+    }
+
+    @Override
+    public ArrayDeque<T> receiver() {
+        return queue;
+    }
+
+    @Override
+    public void onClose() {}
+}

examples/src/main/java/io/zenoh/ZBytesExamples.java

@@ -0,0 +1,155 @@
+//
+// Copyright (c) 2023 ZettaScale Technology
+//
+// 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.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <[email protected]>
+//
+
+package io.zenoh;
+
+import com.google.common.reflect.TypeToken;
+import io.zenoh.bytes.ZBytes;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import static io.zenoh.ext.ZDeserializerKt.zDeserialize;
+import static io.zenoh.ext.ZSerializerKt.zSerialize;
+
+public class ZBytesExamples {
+
+    public static void main(String[] args) {
+
+        /*
+         * ZBytes
+         *
+         * A ZBytes instance can be created from a String and from a Byte Array with the `ZBytes.from(string: String)`
+         * and `ZBytes.from(bytes: byte[])` functions.
+         *
+         * A ZBytes can be converted back into a [String] with the functions [ZBytes.toString] and [ZBytes.tryToString].
+         * Similarly, with [ZBytes.toBytes] you can get the inner byte representation.
+         */
+
+        var exampleString = "example string";
+        var zbytesA = ZBytes.from(exampleString);
+        var outputA = zbytesA.toString();
+        assert exampleString.equals(outputA);
+
+        var exampleBytes = new byte[]{1, 2, 3, 4, 5};
+        var zbytesB = ZBytes.from(exampleBytes);
+        var outputB = zbytesB.toBytes();
+        assert Arrays.equals(exampleBytes, outputB);
+
+        /*
+         * Serialization and deserialization.
+         *
+         * Additionally, the Zenoh API provides a series of serialization and deserialization utilities for processing
+         * the received payloads.
+         *
+         * Serialization and deserialization supports the following types:
+         * - Boolean
+         * - Byte
+         * - Byte Array
+         * - Short
+         * - Int
+         * - Long
+         * - Float
+         * - Double
+         * - String
+         * - List
+         * - Map
+         *
+         * For List and Map, the inner types can be a combination of the above types, including themselves.
+         *
+         * These serialization and deserialization utilities can be used across the Zenoh ecosystem with Zenoh
+         * versions based on other supported languages such as Rust, Python, C and C++.
+         * This works when the types are equivalent (a `Byte` corresponds to an `i8` in Rust, a `Short` to an `i16`, etc).
+         */
+
+        // Boolean example
+        Boolean input1 = true;
+        var zbytes1 = zSerialize(input1, new TypeToken<>() {});
+        Boolean output1 = zDeserialize(zbytes1, new TypeToken<>() {});
+        assert input1.equals(output1);
+
+        // Byte example
+        Byte input2 = 126;
+        var zbytes2 = zSerialize(input2, new TypeToken<>() {});
+        Byte output2 = zDeserialize(zbytes2, new TypeToken<>() {});
+        assert input2.equals(output2);
+
+        // Short example
+        Short input3 = 256;
+        var zbytes3 = zSerialize(input3, new TypeToken<>() {});
+        Short output3 = zDeserialize(zbytes3, new TypeToken<>() {});
+        assert input3.equals(output3);
+
+        // Int example
+        Integer input4 = 123456;
+        var zbytes4 = zSerialize(input4, new TypeToken<>() {});
+        Integer output4 = zDeserialize(zbytes4, new TypeToken<>() {});
+        assert input4.equals(output4);
+
+        // Long example
+        Long input5 = 123456789L;
+        var zbytes5 = zSerialize(input5, new TypeToken<>() {});
+        Long output5 = zDeserialize(zbytes5, new TypeToken<>() {});
+        assert input5.equals(output5);
+
+        // Float example
+        Float input6 = 123.45f;
+        var zbytes6 = zSerialize(input6, new TypeToken<>() {});
+        Float output6 = zDeserialize(zbytes6, new TypeToken<>() {});
+        assert input6.equals(output6);
+
+        // Double example
+        Double input7 = 12345.6789;
+        var zbytes7 = zSerialize(input7, new TypeToken<>() {});
+        Double output7 = zDeserialize(zbytes7, new TypeToken<>() {});
+        assert input7.equals(output7);
+
+        // List example
+        List<Integer> input12 = List.of(1, 2, 3, 4, 5);
+        var zbytes12 = zSerialize(input12, new TypeToken<>() {});
+        List<Integer> output12 = zDeserialize(zbytes12, new TypeToken<>() {});
+        assert input12.equals(output12);
+
+        // String example
+        String input13 = "Hello, World!";
+        var zbytes13 = zSerialize(input13, new TypeToken<>() {});
+        String output13 = zDeserialize(zbytes13, new TypeToken<>() {});
+        assert input13.equals(output13);
+
+        // ByteArray example
+        byte[] input14 = new byte[]{1, 2, 3, 4, 5};
+        var zbytes14 = zSerialize(input14, new TypeToken<>() {});
+        byte[] output14 = zDeserialize(zbytes14, new TypeToken<>() {});
+        assert Arrays.equals(input14, output14);
+
+        // Map example
+        Map<String, Integer> input15 = Map.of("one", 1, "two", 2, "three", 3);
+        var zbytes15 = zSerialize(input15, new TypeToken<>() {});
+        Map<String, Integer> output15 = zDeserialize(zbytes15, new TypeToken<>() {});
+        assert input15.equals(output15);
+
+        // Nested List example
+        List<List<Integer>> input18 = List.of(List.of(1, 2, 3));
+        var zbytes18 = zSerialize(input18, new TypeToken<>() {});
+        List<List<Integer>> output18 = zDeserialize(zbytes18, new TypeToken<>() {});
+        assert input18.equals(output18);
+
+        // Combined types example
+        List<Map<String, Integer>> input19 = List.of(Map.of("a", 1, "b", 2));
+        var zbytes19 = zSerialize(input19, new TypeToken<>() {});
+        List<Map<String, Integer>> output19 = zDeserialize(zbytes19, new TypeToken<>() {});
+        assert input19.equals(output19);
+    }
+}