Add a complete example with a lot of element types (value classes, primitives, sub-structures and sub-lists)

Author: Chuckame

core/build.gradle.kts

@@ -37,7 +37,7 @@ kotlin {
  Require-Kotlin-Version is used to determine whether runtime library with new features can work with old compilers.
  In ideal case, its value should always be 1.4, but some refactorings (e.g. adding a method to the Encoder interface)
  may unexpectedly break old compilers, so it is left out as a safety net. Compiler plugins, starting from 1.4 are instructed
- to reject runtime if runtime's Require-Kotlin-Version is greater then the current compiler.
+ to reject runtime if runtime's Require-Kotlin-Version is greater than the current compiler.
  */
 tasks.withType<Jar>().named(kotlin.jvm().artifactsTaskName) {
 

core/commonMain/src/kotlinx/serialization/encoding/ReorderingCompositeEncoder.kt

@@ -22,12 +22,14 @@ import kotlinx.serialization.modules.*
  * @param mapElementIndex maps the element index to a new positional zero-based index. If this mapper provides the same index for multiple elements, only the last one will be encoded as the previous ones will be overridden. The mapped index just helps to reorder the elements, but the reordered `encode*Element` method calls will still pass the original element index.
  */
 @ExperimentalSerializationApi
-internal class ReorderingCompositeEncoder(
+public class ReorderingCompositeEncoder(
     structureDescriptor: SerialDescriptor,
     private val compositeEncoderDelegate: CompositeEncoder,
     private val mapElementIndex: (SerialDescriptor, Int) -> Int,
 ) : CompositeEncoder {
-    private var bufferedCalls = Array<BufferedCall?>(structureDescriptor.elementsCount) { null }
+    // TODO we should use a map to have buffered calls per descriptor if the same encoder is reused for different structures
+    //  or we need to ensure that this encoder is not reused
+    private val bufferedCalls = Array<BufferedCall?>(structureDescriptor.elementsCount) { null }
 
     override val serializersModule: SerializersModule
         // No need to return a serializers module as it's not used during buffering
@@ -48,6 +50,7 @@ internal class ReorderingCompositeEncoder(
 
     override fun endStructure(descriptor: SerialDescriptor) {
         encodeBufferedFields(descriptor)
+        // TODO should we clear the buffer after encoding? Is it possible to reuse this encoder?
     }
 
     private fun encodeBufferedFields(descriptor: SerialDescriptor) {
@@ -228,19 +231,7 @@ internal class ReorderingCompositeEncoder(
 
         private fun invalidCall(methodName: String): Nothing {
             // This method is normally called by encodeSerializableValue or encodeNullableSerializableValue that is buffered, so we should never go here during buffering as it will be delegated to the concrete CompositeEncoder
-            throw UnsupportedOperationException("$methodName should not be called when reordering fields, as it should be done by encodeSerializableValue or encodeNullableSerializableValue")
+            throw UnsupportedOperationException("encodeSerializableValue or encodeNullableSerializableValue should be called before $methodName")
         }
     }
 }
-
-/**
- * Encodes the [structureDescriptor] elements in a specific order provided by [elementIndexMapper].
- *
- * @param structureDescriptor descriptor of the structure being encoded and reordered
- * @param elementIndexMapper maps the element index to a new positional zero-based index. If this mapper provides the same index for multiple elements, only the last one will be encoded as the previous ones will be overridden. The mapped index just helps to reorder the elements, but the reordered `encode*Element` method calls will still pass the original element index.
- */
-@ExperimentalSerializationApi
-public fun CompositeEncoder.encodeReorderingElements(
-    structureDescriptor: SerialDescriptor,
-    elementIndexMapper: (SerialDescriptor, Int) -> Int,
-): CompositeEncoder = ReorderingCompositeEncoder(structureDescriptor, this, elementIndexMapper)

core/commonTest/src/kotlinx/serialization/encoding/ReorderingCompositeEncoderTest.kt

@@ -13,60 +13,348 @@ import kotlin.test.*
 class ReorderingCompositeEncoderTest {
     @Test
     fun shouldReorderWell() {
-        val first = 42
-        val second = "string"
-        val third = true
-        val value = OuterToBeReordered(Middle(Inner(second, third)), first)
+        val value = AllTypesExample(
+            int = 1,
+            nullableInt = null,
+            intWrapped = IntValue(2),
+            nullableIntWrapped = IntNullableValue(null),
+            intWrappedNullable = IntValue(3),
 
-        val encoder = ReorderingEncoder().apply {
-            encodeSerializableValue(OuterToBeReordered.serializer(), value)
-        }
+            string = "Hello",
+            nullableString = null,
+            stringWrapped = StringValue("World"),
+            nullableStringWrapped = StringNullableValue(null),
+            stringWrappedNullable = StringValue("!!!"),
+
+            boolean = true,
+            nullableBoolean = null,
+            booleanWrapped = BooleanValue(true),
+            nullableBooleanWrapped = BooleanNullableValue(null),
+            booleanWrappedNullable = BooleanValue(false),
+
+            double = 1.0,
+            nullableDouble = null,
+            doubleWrapped = DoubleValue(2.0),
+            nullableDoubleWrapped = DoubleNullableValue(null),
+            doubleWrappedNullable = DoubleValue(3.0),
+
+            nonReorderedList = listOf(1, 2, 3),
+            nonReorderedNullableList = null,
+            nonReorderedListWrapped = ListValue(listOf(4, 5, 6)),
+            nonReorderedNullableListWrapped = ListNullableValue(null),
+            nonReorderedListWrappedNullable = ListNullableValue(listOf(7, 8, 9)),
+            nonReorderedListWrappedNullableValues = ListNullableValues(listOf(null, 8, 9)),
+
+            float = 1.0f,
+            nullableFloat = null,
+            floatWrapped = FloatValue(2.0f),
+            nullableFloatWrapped = FloatNullableValue(null),
+            floatWrappedNullable = FloatValue(3.0f),
+
+            long = 1L,
+            nullableLong = null,
+            longWrapped = LongValue(2L),
+            nullableLongWrapped = LongNullableValue(null),
+            longWrappedNullable = LongValue(3L),
+
+            short = 1,
+            nullableShort = null,
+            shortWrapped = ShortValue(2),
+            nullableShortWrapped = ShortNullableValue(null),
+            shortWrappedNullable = ShortValue(3),
+
+            nonReorderedSubStructure = SubStructure(
+                a = IntValue(10),
+                b = "Sub",
+                c = null,
+                d = null
+            ),
+            nonReorderedNullableSubStructure = null,
+            nonReorderedSubStructureWrapped = SubStructureValue(
+                SubStructure(
+                    a = IntValue(11),
+                    b = "Wrapped",
+                    c = 12L,
+                    d = 13.toByte()
+                )
+            ),
+            nonReorderedNullableSubStructureWrapped = SubStructureNullableValue(null),
+            nonReorderedSubStructureWrappedNullable = SubStructureValue(
+                SubStructure(
+                    a = IntValue(14),
+                    b = "Nullable Wrapped",
+                    c = 15L,
+                    d = 16.toByte()
+                )
+            ),
+
+            byte = 1,
+            nullableByte = null,
+            byteWrapped = ByteValue(2),
+            nullableByteWrapped = ByteNullableValue(null),
+            byteWrappedNullable = ByteValue(3),
 
-        assertContentEquals(actual = encoder.encodedValues, expected = listOf(first, second, third))
+            char = 'A',
+            nullableChar = null,
+            charWrapped = CharValue('B'),
+            nullableCharWrapped = CharNullableValue(null),
+            charWrappedNullable = CharValue('C')
+        )
+
+        val output = StringBuilder()
+        val encoder = LightJsonEncoder(
+            output,
+            descriptorToReorder = AllTypesExample.serializer().descriptor
+        ) { descriptor, index -> descriptor.elementsCount - 1 - index }
+
+        encoder.encodeSerializableValue(AllTypesExample.serializer(), value)
+
+        // the final output should encode the fields in the reverse order, but should not reorder sub-structures
+        assertEquals(
+            actual = output.toString(),
+            expected = """
+            {charWrappedNullable:"C", nullableCharWrapped:null, charWrapped:"B", nullableChar:null, char:"A", byteWrappedNullable:3, nullableByteWrapped:null, byteWrapped:2, nullableByte:null, byte:1, nonReorderedSubStructureWrappedNullable:{a:14, b:"Nullable Wrapped", c:15, d:16}, nonReorderedNullableSubStructureWrapped:null, nonReorderedSubStructureWrapped:{a:11, b:"Wrapped", c:12, d:13}, nonReorderedNullableSubStructure:null, nonReorderedSubStructure:{a:10, b:"Sub", c:null, d:null}, shortWrappedNullable:3, nullableShortWrapped:null, shortWrapped:2, nullableShort:null, short:1, longWrappedNullable:3, nullableLongWrapped:null, longWrapped:2, nullableLong:null, long:1, floatWrappedNullable:3.0, nullableFloatWrapped:null, floatWrapped:2.0, nullableFloat:null, float:1.0, nonReorderedListWrappedNullableValues:[0:null, 1:8, 2:9], nonReorderedListWrappedNullable:[0:7, 1:8, 2:9], nonReorderedNullableListWrapped:null, nonReorderedListWrapped:[0:4, 1:5, 2:6], nonReorderedNullableList:null, nonReorderedList:[0:1, 1:2, 2:3], doubleWrappedNullable:3.0, nullableDoubleWrapped:null, doubleWrapped:2.0, nullableDouble:null, double:1.0, booleanWrappedNullable:false, nullableBooleanWrapped:null, booleanWrapped:true, nullableBoolean:null, boolean:true, stringWrappedNullable:"!!!", nullableStringWrapped:null, stringWrapped:"World", nullableString:null, string:"Hello", intWrappedNullable:3, nullableIntWrapped:null, intWrapped:2, nullableInt:null, int:1}
+        """.trimIndent(),
+        )
     }
+}
 
-    private class ReorderingEncoder(
-        val encodedValues: MutableList<Any?> = mutableListOf()
-    ) : AbstractEncoder() {
-        override val serializersModule: SerializersModule
-            get() = EmptySerializersModule()
+@Serializable
+data class AllTypesExample(
+    val int: Int,
+    val nullableInt: Int?,
+    val intWrapped: IntValue,
+    val nullableIntWrapped: IntNullableValue,
+    val intWrappedNullable: IntValue?,
 
-        override fun encodeValue(value: Any) {
-            encodedValues.add(value)
-        }
+    val string: String,
+    val nullableString: String?,
+    val stringWrapped: StringValue,
+    val nullableStringWrapped: StringNullableValue,
+    val stringWrappedNullable: StringValue?,
+
+    val boolean: Boolean,
+    val nullableBoolean: Boolean?,
+    val booleanWrapped: BooleanValue,
+    val nullableBooleanWrapped: BooleanNullableValue,
+    val booleanWrappedNullable: BooleanValue?,
+
+    val double: Double,
+    val nullableDouble: Double?,
+    val doubleWrapped: DoubleValue,
+    val nullableDoubleWrapped: DoubleNullableValue,
+    val doubleWrappedNullable: DoubleValue?,
+
+    val nonReorderedList: List<Int>,
+    val nonReorderedNullableList: List<Int>?,
+    val nonReorderedListWrapped: ListValue,
+    val nonReorderedNullableListWrapped: ListNullableValue,
+    val nonReorderedListWrappedNullable: ListNullableValue?,
+    val nonReorderedListWrappedNullableValues: ListNullableValues?,
+
+    val float: Float,
+    val nullableFloat: Float?,
+    val floatWrapped: FloatValue,
+    val nullableFloatWrapped: FloatNullableValue,
+    val floatWrappedNullable: FloatValue?,
+
+    val long: Long,
+    val nullableLong: Long?,
+    val longWrapped: LongValue,
+    val nullableLongWrapped: LongNullableValue,
+    val longWrappedNullable: LongValue?,
+
+    val short: Short,
+    val nullableShort: Short?,
+    val shortWrapped: ShortValue,
+    val nullableShortWrapped: ShortNullableValue,
+    val shortWrappedNullable: ShortValue?,
+
+    val nonReorderedSubStructure: SubStructure,
+    val nonReorderedNullableSubStructure: SubStructure?,
+    val nonReorderedSubStructureWrapped: SubStructureValue,
+    val nonReorderedNullableSubStructureWrapped: SubStructureNullableValue,
+    val nonReorderedSubStructureWrappedNullable: SubStructureValue?,
+
+    val byte: Byte,
+    val nullableByte: Byte?,
+    val byteWrapped: ByteValue,
+    val nullableByteWrapped: ByteNullableValue,
+    val byteWrappedNullable: ByteValue?,
+
+    val char: Char,
+    val nullableChar: Char?,
+    val charWrapped: CharValue,
+    val nullableCharWrapped: CharNullableValue,
+    val charWrappedNullable: CharValue?,
+)
+
+@Serializable
+data class SubStructure(
+    val a: IntValue,
+    val b: String,
+    val c: Long?,
+    val d: Byte?,
+)
+
+@Serializable
+@JvmInline
+value class IntValue(val value: Int)
+
+@Serializable
+@JvmInline
+value class StringValue(val value: String)
+
+@Serializable
+@JvmInline
+value class BooleanValue(val value: Boolean)
+
+@Serializable
+@JvmInline
+value class DoubleValue(val value: Double)
+
+@Serializable
+@JvmInline
+value class FloatValue(val value: Float)
+
+@Serializable
+@JvmInline
+value class LongValue(val value: Long)
+
+@Serializable
+@JvmInline
+value class ShortValue(val value: Short)
+
+@Serializable
+@JvmInline
+value class ByteValue(val value: Byte)
+
+@Serializable
+@JvmInline
+value class CharValue(val value: Char)
 
-        override fun encodeNull() {
-            encodedValues.add(null)
+@Serializable
+@JvmInline
+value class SubStructureValue(val value: SubStructure)
+
+@Serializable
+@JvmInline
+value class ListValue(val value: List<Int>)
+
+
+
+
+
+@Serializable
+@JvmInline
+value class IntNullableValue(val value: Int?)
+
+@Serializable
+@JvmInline
+value class StringNullableValue(val value: String?)
+
+@Serializable
+@JvmInline
+value class BooleanNullableValue(val value: Boolean?)
+
+@Serializable
+@JvmInline
+value class DoubleNullableValue(val value: Double?)
+
+@Serializable
+@JvmInline
+value class FloatNullableValue(val value: Float?)
+
+@Serializable
+@JvmInline
+value class LongNullableValue(val value: Long?)
+
+@Serializable
+@JvmInline
+value class ShortNullableValue(val value: Short?)
+
+@Serializable
+@JvmInline
+value class ByteNullableValue(val value: Byte?)
+
+@Serializable
+@JvmInline
+value class CharNullableValue(val value: Char?)
+
+@Serializable
+@JvmInline
+value class SubStructureNullableValue(val value: SubStructure?)
+
+@Serializable
+@JvmInline
+value class ListNullableValue(val value: List<Int>?)
+
+@Serializable
+@JvmInline
+value class ListNullableValues(val value: List<Int?>)
+
+
+
+
+
+private class LightJsonEncoder(
+    val sb: StringBuilder,
+    val descriptorToReorder: SerialDescriptor,
+    val mapElementIndex: (SerialDescriptor, Int) -> Int,
+) : AbstractEncoder() {
+    override val serializersModule: SerializersModule = EmptySerializersModule()
+    var previousDescriptor: SerialDescriptor? = null
+
+    override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
+        if (descriptor.kind == StructureKind.LIST) {
+            sb.append('[')
+        } else {
+            sb.append('{')
+        }
+        previousDescriptor = null
+        if (descriptor == descriptorToReorder) {
+            return ReorderingCompositeEncoder(descriptor, this, mapElementIndex)
         }
+        return this
+    }
 
-        override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
-            return BasicCompositeEncoder().encodeReorderingElements(descriptor) { _, index ->
-                // invert fields
-                if (index == 0) 1 else 0
-            }
+    override fun endStructure(descriptor: SerialDescriptor) {
+        if (descriptor.kind == StructureKind.LIST) {
+            sb.append(']')
+        } else {
+            sb.append('}')
         }
+    }
 
-        private inner class BasicCompositeEncoder : AbstractEncoder() {
-            override val serializersModule: SerializersModule
-                get() = EmptySerializersModule()
+    override fun encodeElement(descriptor: SerialDescriptor, index: Int): Boolean {
+        if (previousDescriptor == null) {
+            previousDescriptor = descriptor
+        } else {
+            previousDescriptor = descriptor
+            sb.append(", ")
+        }
+        sb.append(descriptor.getElementName(index))
+        sb.append(':')
+        return true
+    }
 
-            override fun encodeValue(value: Any) {
-                encodedValues.add(value)
-            }
+    override fun encodeNull() {
+        sb.append("null")
+    }
 
-            override fun encodeNull() {
-                encodedValues.add(null)
-            }
-        }
+    override fun encodeValue(value: Any) {
+        sb.append(value)
     }
 
-    @Serializable
-    private data class OuterToBeReordered(val a: Middle, val b: Int)
+    override fun encodeString(value: String) {
+        sb.append('"')
+        sb.append(value)
+        sb.append('"')
+    }
 
-    @JvmInline
-    @Serializable
-    private value class Middle(val i: Inner)
+    override fun encodeInline(descriptor: SerialDescriptor): Encoder {
+        return super.encodeInline(descriptor)
+    }
 
-    @Serializable
-    private data class Inner(val c: String, val d: Boolean)
+    override fun encodeChar(value: Char) = encodeString(value.toString())
 }