Enhance BufDecoder and BufEncoder with custom serializer support and add tests for custom serialization

Author: twisti-dev

src/main/kotlin/dev/slne/surf/bytebufserializer/internal/BufDecoder.kt

@@ -21,21 +21,44 @@ class BufDecoder<B : ByteBuf>(
         return elementIndex++
     }
 
-    override fun decodeBoolean(): Boolean = buf.readBoolean()
-    override fun decodeByte(): Byte = buf.readByte()
-    override fun decodeShort(): Short = buf.readShort()
-    override fun decodeInt(): Int = buf.readInt()
-    override fun decodeLong(): Long = buf.readLong()
-    override fun decodeFloat(): Float = buf.readFloat()
-    override fun decodeDouble(): Double = buf.readDouble()
-    override fun decodeChar(): Char = buf.readChar().toChar()
+    override fun decodeBoolean(): Boolean = useCustomOr {
+        buf.readBoolean()
+    }
+
+    override fun decodeByte(): Byte = useCustomOr {
+        buf.readByte()
+    }
+
+    override fun decodeShort(): Short = useCustomOr {
+        buf.readShort()
+    }
+
+    override fun decodeInt(): Int = useCustomOr {
+        buf.readInt()
+    }
+
+    override fun decodeLong(): Long = useCustomOr {
+        buf.readLong()
+    }
+
+    override fun decodeFloat(): Float = useCustomOr {
+        buf.readFloat()
+    }
+
+    override fun decodeDouble(): Double = useCustomOr {
+        buf.readDouble()
+    }
+
+    override fun decodeChar(): Char = useCustomOr {
+        buf.readChar().toChar()
+    }
 
 
-    override fun decodeString(): String {
+    override fun decodeString(): String = useCustomOr {
         val length = buf.readInt()
         val bytes = ByteArray(length)
         buf.readBytes(bytes)
-        return String(bytes, Charsets.UTF_8)
+        String(bytes, Charsets.UTF_8)
     }
 
     override fun decodeEnum(enumDescriptor: SerialDescriptor): Int {
@@ -52,8 +75,18 @@ class BufDecoder<B : ByteBuf>(
     }
 
     override fun decodeCollectionSize(descriptor: SerialDescriptor): Int =
-        buf.readInt().also { elementsCount = it }
+        decodeInt().also { elementsCount = it }
 
     override fun decodeSequentially(): Boolean = true
     override fun decodeNotNullMark(): Boolean = decodeBoolean()
+
+    private inline fun <reified T : Any> useCustomOr(fallback: () -> T): T {
+        val serializer = serializersModule.getContextual(T::class)
+
+        return if (serializer != null) {
+            decodeSerializableValue(serializer)
+        } else {
+            fallback()
+        }
+    }
 }

src/main/kotlin/dev/slne/surf/bytebufserializer/internal/BufEncoder.kt

@@ -13,39 +13,39 @@ class BufEncoder<B : ByteBuf>(
     override val serializersModule: SerializersModule,
     private val encodeEnumWithOrdinal: Boolean,
 ) : AbstractEncoder() {
-    override fun encodeBoolean(value: Boolean) {
+    override fun encodeBoolean(value: Boolean) = useCustomOr(value) {
         buf.writeBoolean(value)
     }
 
-    override fun encodeByte(value: Byte) {
+    override fun encodeByte(value: Byte) = useCustomOr(value) {
         buf.writeByte(value.toInt())
     }
 
-    override fun encodeShort(value: Short) {
+    override fun encodeShort(value: Short) = useCustomOr(value) {
         buf.writeShort(value.toInt())
     }
 
-    override fun encodeInt(value: Int) {
+    override fun encodeInt(value: Int) = useCustomOr(value) {
         buf.writeInt(value)
     }
 
-    override fun encodeLong(value: Long) {
+    override fun encodeLong(value: Long) = useCustomOr(value) {
         buf.writeLong(value)
     }
 
-    override fun encodeFloat(value: Float) {
+    override fun encodeFloat(value: Float) = useCustomOr(value) {
         buf.writeFloat(value)
     }
 
-    override fun encodeDouble(value: Double) {
+    override fun encodeDouble(value: Double) = useCustomOr(value) {
         buf.writeDouble(value)
     }
 
-    override fun encodeChar(value: Char) {
+    override fun encodeChar(value: Char) = useCustomOr(value) {
         buf.writeChar(value.code)
     }
 
-    override fun encodeString(value: String) {
+    override fun encodeString(value: String) = useCustomOr(value) {
         val bytes = value.toByteArray(Charsets.UTF_8)
         buf.writeInt(bytes.size)
         buf.writeBytes(bytes)
@@ -67,12 +67,21 @@ class BufEncoder<B : ByteBuf>(
         return this
     }
 
-
     override fun encodeNull() {
         encodeBoolean(false)
     }
 
     override fun encodeNotNullMark() {
         encodeBoolean(true)
     }
+
+    private inline fun <reified T : Any> useCustomOr(value: T, fallback: () -> Unit) {
+        val serializer = serializersModule.getContextual(T::class)
+
+        if (serializer != null) {
+            encodeSerializableValue(serializer, value)
+        } else {
+            fallback()
+        }
+    }
 }

src/test/kotlin/dev/slne/surf/bytebufserializer/OverridingDefaultTypeSerializer.kt

@@ -0,0 +1,61 @@
+package dev.slne.surf.bytebufserializer
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.modules.SerializersModule
+import kotlinx.serialization.modules.contextual
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+
+class OverridingDefaultTypeSerializer {
+
+    private val bufFormat = Buf(SerializersModule {
+        contextual(CustomStringSerializer)
+    })
+
+    @Serializable
+    data class Player(val name: String, val score: Int)
+
+    @Test
+    fun `test encode using custom serializer`() {
+        val player = Player("Alice", 42)
+
+        assertFailsWith<AssertionError> {
+            val bytes = bufFormat.encodeToByteArray(player)
+            println(bytes.joinToString())
+        }
+    }
+
+    @Test
+    fun `test decode using custom serializer`() {
+        val bytes = byteArrayOf(0, 0, 0, 5, 65, 108, 105, 99, 101, 0, 0, 0, 42)
+
+        assertFailsWith<AssertionError> {
+            bufFormat.decodeFromByteArray<Player>(bytes)
+        }
+    }
+}
+
+object CustomStringSerializer : KSerializer<String> {
+    override val descriptor: SerialDescriptor =
+        PrimitiveSerialDescriptor("CustomStringSerializer", PrimitiveKind.STRING)
+
+    @OptIn(ExperimentalSerializationApi::class)
+    override fun serialize(
+        encoder: Encoder,
+        value: String
+    ) {
+        throw AssertionError("This exception is expected")
+    }
+
+    @OptIn(ExperimentalSerializationApi::class)
+    override fun deserialize(decoder: Decoder): String {
+        throw AssertionError("This exception is expected")
+    }
+}