Add UnionCodec and UnionStreamCodec

Author: LukynkaCZE

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style=official
-tide.version=3.5
+tide.version=3.6

src/main/kotlin/io/github/dockyardmc/tide/codec/Codec.kt

@@ -29,6 +29,18 @@ interface Codec<T> {
         return DefaultCodec<T>(this, default)
     }
 
+    fun <R> union(serializers: (T) -> StructCodec<out R>, keyFunc: (R) -> T): StructCodec<R> {
+        return union("type", this, serializers, keyFunc)
+    }
+
+    fun <R> union(keyCodec: Codec<T>, serializers: (T) -> StructCodec<out R>, keyFunc: (R) -> T): StructCodec<R> {
+        return union("type", keyCodec, serializers, keyFunc)
+    }
+
+    fun <R> union(keyFiled: String, keyCodec: Codec<T>, serializers: (T) -> StructCodec<out R>, keyFunc: (R) -> T): StructCodec<R> {
+        return UnionCodec<T, R>(keyFiled, keyCodec, serializers, keyFunc)
+    }
+
     class EncodingException(override val message: String) : Exception()
     class DecodingException(override val message: String) : Exception()
 

src/main/kotlin/io/github/dockyardmc/tide/codec/UnionCodec.kt

@@ -0,0 +1,20 @@
+package io.github.dockyardmc.tide.codec
+
+import io.github.dockyardmc.tide.transcoder.Transcoder
+
+data class UnionCodec<T, R>(val keyFiled: String, val keyCodec: Codec<T>, val serializers: (T) -> StructCodec<out R>, val keyFunc: (R) -> T) : StructCodec<R> {
+
+    override fun <T> decodeFromMap(transcoder: Transcoder<T>, map: Transcoder.VirtualMap<T>): R {
+        val key = keyCodec.decode(transcoder, map.getValue(keyFiled))
+        val serializer = serializers.invoke(key)
+        return serializer.decodeFromMap(transcoder, map)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T> encodeToMap(transcoder: Transcoder<T>, value: R, map: Transcoder.VirtualMapBuilder<T>): T {
+        val key = keyFunc.invoke(value)
+        val serializer = serializers.invoke(key) as StructCodec<R>
+        map.put(keyFiled, keyCodec.encode(transcoder, key))
+        return serializer.encodeToMap(transcoder, value, map)
+    }
+}

src/main/kotlin/io/github/dockyardmc/tide/stream/StreamCodec.kt

@@ -1,8 +1,6 @@
 package io.github.dockyardmc.tide.stream
 
-import io.github.dockyardmc.tide.codec.Codec
 import io.github.dockyardmc.tide.codec.CodecUtils
-import io.github.dockyardmc.tide.codec.RecursiveCodec
 import io.netty.buffer.ByteBuf
 import java.util.*
 
@@ -30,6 +28,10 @@ interface StreamCodec<T> {
         return ListStreamCodec<T>(this)
     }
 
+    fun <R, TR : R> union(serializers: (T) -> StreamCodec<out TR>, keyFunc: (R) -> T): UnionStreamCodec<TR, T, TR> {
+        return UnionStreamCodec(this, keyFunc, serializers)
+    }
+
 
     companion object {
         val UNIT = object : StreamCodec<Unit> {

src/main/kotlin/io/github/dockyardmc/tide/stream/UnionStreamCodec.kt

@@ -0,0 +1,25 @@
+package io.github.dockyardmc.tide.stream
+
+import io.netty.buffer.ByteBuf
+
+data class UnionStreamCodec<T, K, out TR : T>(
+    val keyCodec: StreamCodec<K>,
+    val keyFunc: (T) -> K,
+    val serializers: (K) -> StreamCodec<out TR>
+) : StreamCodec<T> {
+
+    @Suppress("UNCHECKED_CAST")
+    override fun write(buffer: ByteBuf, value: T) {
+        val key = keyFunc.invoke(value)
+        keyCodec.write(buffer, key)
+        val serializer = serializers.invoke(key)
+        (serializer as StreamCodec<TR>).write(buffer, value as TR)
+    }
+
+    override fun read(buffer: ByteBuf): T {
+        val key = keyCodec.read(buffer)
+        val serializer = serializers.invoke(key)
+        return serializer.read(buffer)
+    }
+
+}

src/test/kotlin/io/github/dockyardmc/tide/UnionCodecTest.kt

@@ -0,0 +1,146 @@
+package io.github.dockyardmc.tide
+
+import io.github.dockyardmc.tide.codec.Codec
+import io.github.dockyardmc.tide.codec.StructCodec
+import io.github.dockyardmc.tide.stream.StreamCodec
+import io.github.dockyardmc.tide.transcoder.JsonTranscoder
+import io.netty.buffer.Unpooled
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+class UnionCodecTest {
+
+    sealed interface ConsumeEffect {
+        companion object {
+            val STREAM_CODEC = StreamCodec.enum<Type>().union(
+                { type ->
+                    when (type) {
+                        Type.APPLY_EFFECTS -> ApplyEffects.STREAM_CODEC
+                        Type.REMOVE_EFFECTS -> RemoveEffects.STREAM_CODEC
+                        Type.PLAY_SOUND -> PlaySound.STREAM_CODEC
+                        Type.TELEPORT -> Teleport.STREAM_CODEC
+                    }
+                },
+                { consumeEffect ->
+                    when (consumeEffect) {
+                        is ApplyEffects -> Type.APPLY_EFFECTS
+                        is RemoveEffects -> Type.REMOVE_EFFECTS
+                        is PlaySound -> Type.PLAY_SOUND
+                        is Teleport -> Type.TELEPORT
+                    }
+                })
+
+            val CODEC = Codec.enum<Type>().union<ConsumeEffect>(
+                { type ->
+                    when (type) {
+                        Type.APPLY_EFFECTS -> ApplyEffects.CODEC
+                        Type.REMOVE_EFFECTS -> RemoveEffects.CODEC
+                        Type.PLAY_SOUND -> PlaySound.CODEC
+                        Type.TELEPORT -> Teleport.CODEC
+                    }
+                },
+                { consumeEffect ->
+                    when (consumeEffect) {
+                        is ApplyEffects -> Type.APPLY_EFFECTS
+                        is RemoveEffects -> Type.REMOVE_EFFECTS
+                        is PlaySound -> Type.PLAY_SOUND
+                        is Teleport -> Type.TELEPORT
+                    }
+                })
+
+        }
+
+        fun consumeEffectToType(consumeEffect: ConsumeEffect): Type {
+            return when (consumeEffect) {
+                is ApplyEffects -> Type.APPLY_EFFECTS
+                is RemoveEffects -> Type.REMOVE_EFFECTS
+                is PlaySound -> Type.PLAY_SOUND
+                is Teleport -> Type.TELEPORT
+            }
+        }
+
+        enum class Type {
+            APPLY_EFFECTS,
+            REMOVE_EFFECTS,
+            PLAY_SOUND,
+            TELEPORT
+        }
+
+        data class ApplyEffects(val effects: List<String>) : ConsumeEffect {
+            companion object {
+                val CODEC = StructCodec.of(
+                    "effects", Codec.STRING.list(), ApplyEffects::effects,
+                    ::ApplyEffects
+                )
+
+                val STREAM_CODEC = StreamCodec.of(
+                    StreamCodec.STRING.list(), ApplyEffects::effects,
+                    ::ApplyEffects
+                )
+            }
+        }
+
+        data class RemoveEffects(val effects: List<String>) : ConsumeEffect {
+            companion object {
+                val CODEC = StructCodec.of(
+                    "effects", Codec.STRING.list(), RemoveEffects::effects,
+                    ::RemoveEffects
+                )
+
+                val STREAM_CODEC = StreamCodec.of(
+                    StreamCodec.STRING.list(), RemoveEffects::effects,
+                    ::RemoveEffects
+                )
+            }
+        }
+
+        data class PlaySound(val sound: String, val range: Float? = null) : ConsumeEffect {
+            companion object {
+                val CODEC = StructCodec.of(
+                    "sound", Codec.STRING, PlaySound::sound,
+                    "range", Codec.FLOAT.optional(), PlaySound::range,
+                    ::PlaySound
+                )
+
+                val STREAM_CODEC = StreamCodec.of(
+                    StreamCodec.STRING, PlaySound::sound,
+                    StreamCodec.FLOAT.optional(), PlaySound::range,
+                    ::PlaySound
+                )
+            }
+        }
+
+        data class Teleport(val radius: Float? = 1.6f) : ConsumeEffect {
+            companion object {
+                val CODEC = StructCodec.of(
+                    "radius", Codec.FLOAT.optional(), Teleport::radius,
+                    ::Teleport
+                )
+
+                val STREAM_CODEC = StreamCodec.of(
+                    StreamCodec.FLOAT.optional(), Teleport::radius,
+                    ::Teleport
+                )
+            }
+        }
+
+    }
+
+    @Test
+    fun testUnionCodec() {
+        val tp = ConsumeEffect.ApplyEffects(listOf("minecraft:speed", "minecraft:gayness"))
+        val encoded = ConsumeEffect.CODEC.encode(JsonTranscoder, tp)
+        val decoded = ConsumeEffect.CODEC.decode(JsonTranscoder, encoded)
+        assertEquals(tp, decoded)
+    }
+
+    @Test
+    fun testUnionStreamCodec() {
+        val tp = ConsumeEffect.ApplyEffects(listOf("minecraft:speed", "minecraft:gayness"))
+        val buffer = Unpooled.buffer()
+        ConsumeEffect.STREAM_CODEC.write(buffer, tp)
+        val decoded = ConsumeEffect.STREAM_CODEC.read(buffer)
+        assertEquals(tp, decoded)
+    }
+
+}