Merging dev/1.0.0 into main

examples/build.gradle.kts

@@ -31,6 +31,7 @@ dependencies {
 
 tasks {
     val examples = listOf(
+        "ZBytes",
         "ZDelete",
         "ZGet",
         "ZPub",

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

@@ -14,7 +14,6 @@
 
 package io.zenoh
 
-import io.zenoh.sample.Attachment
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.json.Json
@@ -57,10 +56,12 @@ internal fun loadConfig(
     noMulticastScouting: Boolean,
     mode: String?
 ): Config {
-    val config = if (emptyArgs) {
+    return if (emptyArgs) {
         Config.default()
     } else {
-        configFile?.let { Config.from(Path(it)) } ?: run {
+        configFile?.let {
+            Config.from(path = Path(it))
+        } ?: run {
             val connect = Connect(connectEndpoints)
             val listen = Listen(listenEndpoints)
             val scouting = Scouting(Multicast(!noMulticastScouting))
@@ -69,10 +70,4 @@ internal fun loadConfig(
             Config.from(jsonConfig)
         }
     }
-    return config
-}
-
-internal fun decodeAttachment(attachment: String): Attachment {
-    val pairs = attachment.split("&").map { it.split("=").let { (k, v) -> k.toByteArray() to v.toByteArray() } }
-    return Attachment.Builder().addAll(pairs).res()
 }

examples/src/main/kotlin/io.zenoh/ZBytes.kt

@@ -0,0 +1,237 @@
+package io.zenoh
+
+import io.zenoh.protocol.*
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.reflect.typeOf
+
+fun main() {
+
+    /***********************************************
+     * Standard serialization and deserialization. *
+     ***********************************************/
+
+    /** Numeric: byte, short, int, float, double */
+    val intInput = 1234
+    var payload = ZBytes.from(intInput)
+    var intOutput = payload.deserialize<Int>().getOrThrow()
+    check(intInput == intOutput)
+
+    // Alternatively you can serialize into the type.
+    payload = ZBytes.serialize(intInput).getOrThrow()
+    intOutput = payload.deserialize<Int>().getOrThrow()
+    check(intInput == intOutput)
+
+    // Alternatively, `Numeric.into()`: ZBytes can be used
+    payload = intInput.into()
+    intOutput = payload.deserialize<Int>().getOrThrow()
+    check(intInput == intOutput)
+
+    // Another example with float
+    val floatInput = 3.1415f
+    payload = ZBytes.from(floatInput)
+    val floatOutput = payload.deserialize<Float>().getOrThrow()
+    check(floatInput == floatOutput)
+
+    /** String serialization and deserialization. */
+    val stringInput = "example"
+    payload = ZBytes.from(stringInput)
+    // Alternatively, you can also call `String.into()` to convert
+    // a string into a ZBytes object:
+    // payload = stringInput.into()
+    var stringOutput = payload.deserialize<String>().getOrThrow()
+    check(stringInput == stringOutput)
+
+    // For the case of strings, ZBytes::toString() is equivalent:
+    stringOutput = payload.toString()
+    check(stringInput == stringOutput)
+
+    /** ByteArray serialization and deserialization. */
+    val byteArrayInput = "example".toByteArray()
+    payload = ZBytes.from(byteArrayInput) // Equivalent to `byteArrayInput.into()`
+    var byteArrayOutput = payload.deserialize<ByteArray>().getOrThrow()
+    check(byteArrayInput.contentEquals(byteArrayOutput))
+    // Alternatively, we can directly access the bytes of property of ZBytes:
+    byteArrayOutput = payload.toByteArray()
+    check(byteArrayInput.contentEquals(byteArrayOutput))
+
+    /** List serialization and deserialization.
+     *
+     * Supported types: String, ByteArray, ZBytes, Byte, Short, Int, Long, Float and Double.
+     */
+    val inputList = listOf("sample1", "sample2", "sample3")
+    payload = ZBytes.serialize(inputList).getOrThrow()
+    val outputList = payload.deserialize<List<String>>().getOrThrow()
+    check(inputList == outputList)
+
+    val inputListZBytes = inputList.map { value -> value.into() }
+    payload = ZBytes.serialize(inputListZBytes).getOrThrow()
+    val outputListZBytes = payload.deserialize<List<ZBytes>>().getOrThrow()
+    check(inputListZBytes == outputListZBytes)
+
+    val inputListByteArray = inputList.map { value -> value.toByteArray() }
+    payload = ZBytes.serialize(inputListByteArray).getOrThrow()
+    val outputListByteArray = payload.deserialize<List<ByteArray>>().getOrThrow()
+    check(compareByteArrayLists(inputListByteArray, outputListByteArray))
+
+    /**
+     * Map serialization and deserialization.
+     *
+     * Maps with the following Type combinations are supported: String, ByteArray, ZBytes, Byte, Short, Int, Long, Float and Double.
+     */
+    val inputMap = mapOf("key1" to "value1", "key2" to "value2", "key3" to "value3")
+    payload = ZBytes.serialize(inputMap).getOrThrow()
+    val outputMap = payload.deserialize<Map<String, String>>().getOrThrow()
+    check(inputMap == outputMap)
+
+    val combinedInputMap = mapOf("key1" to ZBytes.from("zbytes1"), "key2" to ZBytes.from("zbytes2"))
+    payload = ZBytes.serialize(combinedInputMap).getOrThrow()
+    val combinedOutputMap = payload.deserialize<Map<String, ZBytes>>().getOrThrow()
+    check(combinedInputMap == combinedOutputMap)
+
+    /*********************************************
+     * Custom serialization and deserialization. *
+     *********************************************/
+
+    /**
+     * The examples below use [MyZBytes], an example class consisting that implements the [Serializable] interface.
+     *
+     * In order for the serialization and deserialization to be successful on a custom class,
+     * the class itself must override the `into(): ZBytes` function, but also the companion
+     * object must implement the [Deserializable.From] interface.
+     *
+     * @see MyZBytes
+     */
+    val inputMyZBytes = MyZBytes("example")
+    payload = ZBytes.serialize(inputMyZBytes).getOrThrow()
+    val outputMyZBytes = payload.deserialize<MyZBytes>().getOrThrow()
+    check(inputMyZBytes == outputMyZBytes)
+
+    /** List of MyZBytes. */
+    val inputListMyZBytes = inputList.map { value -> MyZBytes(value) }
+    payload = ZBytes.serialize<List<MyZBytes>>(inputListMyZBytes).getOrThrow()
+    val outputListMyZBytes = payload.deserialize<List<MyZBytes>>().getOrThrow()
+    check(inputListMyZBytes == outputListMyZBytes)
+
+    /** Map of MyZBytes. */
+    val inputMapMyZBytes = inputMap.map { (k, v) -> MyZBytes(k) to MyZBytes(v)}.toMap()
+    payload = ZBytes.serialize<Map<MyZBytes, MyZBytes>>(inputMapMyZBytes).getOrThrow()
+    val outputMapMyZBytes = payload.deserialize<Map<MyZBytes, MyZBytes>>().getOrThrow()
+    check(inputMapMyZBytes == outputMapMyZBytes)
+
+    val combinedMap = mapOf(MyZBytes("foo") to 1, MyZBytes("bar") to 2)
+    payload = ZBytes.serialize<Map<MyZBytes, Int>>(combinedMap).getOrThrow()
+    val combinedOutput = payload.deserialize<Map<MyZBytes, Int>>().getOrThrow()
+    check(combinedMap == combinedOutput)
+
+    /**
+     * Providing a map of deserializers.
+     *
+     * Alternatively, [ZBytes.deserialize] also accepts a deserializers parameter of type
+     * `Map<KType, KFunction1<ByteArray, Any>>`. That is, a map of types that is associated
+     * to a function receiving a ByteArray, that returns Any. This way, you can provide a series
+     * of deserializer functions that extend the deserialization mechanisms we provide by default.
+     *
+     * For example, let's say we have a custom map serializer, with its own deserializer:
+     */
+    val fooMap = mapOf(Foo("foo1") to Foo("bar1"), Foo("foo2") to Foo("bar2"))
+    val fooMapSerialized = ZBytes.from(serializeFooMap(fooMap))
+    val deserializersMap = mapOf(typeOf<Map<Foo, Foo>>() to ::deserializeFooMap)
+    val deserializedFooMap = fooMapSerialized.deserialize<Map<Foo, Foo>>(deserializersMap).getOrThrow()
+    check(fooMap == deserializedFooMap)
+}
+
+class MyZBytes(val content: String) : Serializable, Deserializable {
+
+    override fun into(): ZBytes = content.into()
+
+    companion object : Deserializable.From {
+        override fun from(zbytes: ZBytes): MyZBytes {
+            return MyZBytes(zbytes.toString())
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as MyZBytes
+
+        return content == other.content
+    }
+
+    override fun hashCode(): Int {
+        return content.hashCode()
+    }
+}
+
+/** Example class for the deserialization map examples. */
+class Foo(val content: String) {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as Foo
+
+        return content == other.content
+    }
+
+    override fun hashCode(): Int {
+        return content.hashCode()
+    }
+}
+
+/** Example serializer and deserializer. */
+private fun serializeFooMap(testMap: Map<Foo, Foo>): ByteArray {
+    return testMap.map {
+        val key = it.key.content.toByteArray()
+        val keyLength = ByteBuffer.allocate(Int.SIZE_BYTES).order(ByteOrder.LITTLE_ENDIAN).putInt(key.size).array()
+        val value = it.value.content.toByteArray()
+        val valueLength =
+            ByteBuffer.allocate(Int.SIZE_BYTES).order(ByteOrder.LITTLE_ENDIAN).putInt(value.size).array()
+        keyLength + key + valueLength + value
+    }.reduce { acc, bytes -> acc + bytes }
+}
+
+private fun deserializeFooMap(serializedMap: ZBytes): Map<Foo, Foo> {
+    var idx = 0
+    var sliceSize: Int
+    val bytes = serializedMap.toByteArray()
+    val decodedMap = mutableMapOf<Foo, Foo>()
+    while (idx < bytes.size) {
+        sliceSize = ByteBuffer.wrap(bytes.sliceArray(IntRange(idx, idx + Int.SIZE_BYTES - 1)))
+            .order(ByteOrder.LITTLE_ENDIAN).int
+        idx += Int.SIZE_BYTES
+
+        val key = bytes.sliceArray(IntRange(idx, idx + sliceSize - 1))
+        idx += sliceSize
+
+        sliceSize = ByteBuffer.wrap(bytes.sliceArray(IntRange(idx, idx + Int.SIZE_BYTES - 1))).order(
+            ByteOrder.LITTLE_ENDIAN
+        ).int
+        idx += Int.SIZE_BYTES
+
+        val value = bytes.sliceArray(IntRange(idx, idx + sliceSize - 1))
+        idx += sliceSize
+
+        decodedMap[Foo(key.decodeToString())] = Foo(value.decodeToString())
+    }
+    return decodedMap
+}
+
+/** Utils for this example. */
+
+private fun compareByteArrayLists(list1: List<ByteArray>, list2: List<ByteArray>): Boolean {
+    if (list1.size != list2.size) {
+        return false
+    }
+
+    for (i in list1.indices) {
+        if (!list1[i].contentEquals(list2[i])) {
+            return false
+        }
+    }
+
+    return true
+}

examples/src/main/kotlin/io.zenoh/ZDelete.kt

@@ -21,6 +21,19 @@ import io.zenoh.keyexpr.intoKeyExpr
 class ZDelete(private val emptyArgs: Boolean) : CliktCommand(
     help = "Zenoh Delete example"
 ) {
+    override fun run() {
+        val config = loadConfig(emptyArgs, configFile, connect, listen, noMulticastScouting, mode)
+
+        println("Opening session...")
+        Session.open(config).onSuccess { session ->
+            session.use {
+                key.intoKeyExpr().onSuccess { keyExpr ->
+                    println("Deleting resources matching '$keyExpr'...")
+                    session.delete(keyExpr)
+                }
+            }
+        }
+    }
 
     private val connect: List<String> by option(
         "-e", "--connect", help = "Endpoints to connect to.", metavar = "connect"
@@ -41,22 +54,6 @@ class ZDelete(private val emptyArgs: Boolean) : CliktCommand(
     private val noMulticastScouting: Boolean by option(
         "--no-multicast-scouting", help = "Disable the multicast-based scouting mechanism."
     ).flag(default = false)
-
-    override fun run() {
-        val config = loadConfig(emptyArgs, configFile, connect, listen, noMulticastScouting,mode)
-
-        println("Opening session...")
-        Session.open(config).onSuccess { session ->
-            session.use {
-                key.intoKeyExpr().onSuccess { keyExpr ->
-                    keyExpr.use {
-                        println("Deleting resources matching '$keyExpr'...")
-                        session.delete(keyExpr).res()
-                    }
-                }
-            }
-        }
-    }
 }
 
 fun main(args: Array<String>) = ZDelete(args.isEmpty()).main(args)