Skip to content

Commit ef214ec

Browse files
ChuckameChuckame
committed
feat: Add a way to reorder elements during encoding
1 parent 0013192 commit ef214ec

File tree

2 files changed

+318
-0
lines changed

2 files changed

+318
-0
lines changed

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

+246
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,246 @@
1+
/*
2+
* Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
3+
*/
4+
5+
package kotlinx.serialization.encoding
6+
7+
import kotlinx.serialization.*
8+
import kotlinx.serialization.descriptors.*
9+
import kotlinx.serialization.modules.*
10+
11+
12+
/**
13+
* Encodes composite elements in a specific order managed by [mapElementIndex].
14+
*
15+
* This encoder will replicate the behavior of a standard encoding, but calling the `encode*Element` methods in
16+
* the order defined by [mapElementIndex]. It first buffers each `encode*Element` calls in an array following
17+
* the given indexes using [mapElementIndex], then when [endStructure] is called, it encodes the buffered calls
18+
* in the expected order by replaying the previous calls on the given [compositeEncoderDelegate].
19+
*
20+
* @param compositeEncoderDelegate the [CompositeEncoder] to be used to encode the given descriptor's elements in the expected order.
21+
* @param structureDescriptor descriptor of the structure being encoded and reordered
22+
* @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.
23+
*/
24+
@ExperimentalSerializationApi
25+
internal class ReorderingCompositeEncoder(
26+
structureDescriptor: SerialDescriptor,
27+
private val compositeEncoderDelegate: CompositeEncoder,
28+
private val mapElementIndex: (SerialDescriptor, Int) -> Int,
29+
) : CompositeEncoder {
30+
private var bufferedCalls = Array<BufferedCall?>(structureDescriptor.elementsCount) { null }
31+
32+
override val serializersModule: SerializersModule
33+
// No need to return a serializers module as it's not used during buffering
34+
get() = EmptySerializersModule()
35+
36+
private data class BufferedCall(
37+
val originalElementIndex: Int,
38+
val encoder: () -> Unit,
39+
)
40+
41+
private fun bufferEncoding(
42+
descriptor: SerialDescriptor,
43+
index: Int,
44+
encoder: () -> Unit
45+
) {
46+
bufferedCalls[mapElementIndex(descriptor, index)] = BufferedCall(index, encoder)
47+
}
48+
49+
override fun endStructure(descriptor: SerialDescriptor) {
50+
encodeBufferedFields(descriptor)
51+
}
52+
53+
private fun encodeBufferedFields(descriptor: SerialDescriptor) {
54+
bufferedCalls.filterNotNull().forEach { fieldToEncode ->
55+
fieldToEncode.encoder()
56+
}
57+
compositeEncoderDelegate.endStructure(descriptor)
58+
}
59+
60+
override fun encodeBooleanElement(descriptor: SerialDescriptor, index: Int, value: Boolean) {
61+
bufferEncoding(descriptor, index) {
62+
compositeEncoderDelegate.encodeBooleanElement(descriptor, index, value)
63+
}
64+
}
65+
66+
override fun encodeByteElement(descriptor: SerialDescriptor, index: Int, value: Byte) {
67+
bufferEncoding(descriptor, index) {
68+
compositeEncoderDelegate.encodeByteElement(descriptor, index, value)
69+
}
70+
}
71+
72+
override fun encodeCharElement(descriptor: SerialDescriptor, index: Int, value: Char) {
73+
bufferEncoding(descriptor, index) {
74+
compositeEncoderDelegate.encodeCharElement(descriptor, index, value)
75+
}
76+
}
77+
78+
override fun encodeDoubleElement(descriptor: SerialDescriptor, index: Int, value: Double) {
79+
bufferEncoding(descriptor, index) {
80+
compositeEncoderDelegate.encodeDoubleElement(descriptor, index, value)
81+
}
82+
}
83+
84+
override fun encodeFloatElement(descriptor: SerialDescriptor, index: Int, value: Float) {
85+
bufferEncoding(descriptor, index) {
86+
compositeEncoderDelegate.encodeFloatElement(descriptor, index, value)
87+
}
88+
}
89+
90+
override fun encodeIntElement(descriptor: SerialDescriptor, index: Int, value: Int) {
91+
bufferEncoding(descriptor, index) {
92+
compositeEncoderDelegate.encodeIntElement(descriptor, index, value)
93+
}
94+
}
95+
96+
override fun encodeLongElement(descriptor: SerialDescriptor, index: Int, value: Long) {
97+
bufferEncoding(descriptor, index) {
98+
compositeEncoderDelegate.encodeLongElement(descriptor, index, value)
99+
}
100+
}
101+
102+
override fun <T : Any> encodeNullableSerializableElement(
103+
descriptor: SerialDescriptor,
104+
index: Int,
105+
serializer: SerializationStrategy<T>,
106+
value: T?
107+
) {
108+
bufferEncoding(descriptor, index) {
109+
compositeEncoderDelegate.encodeNullableSerializableElement(descriptor, index, serializer, value)
110+
}
111+
}
112+
113+
override fun <T> encodeSerializableElement(
114+
descriptor: SerialDescriptor,
115+
index: Int,
116+
serializer: SerializationStrategy<T>,
117+
value: T
118+
) {
119+
bufferEncoding(descriptor, index) {
120+
compositeEncoderDelegate.encodeSerializableElement(descriptor, index, serializer, value)
121+
}
122+
}
123+
124+
override fun encodeShortElement(descriptor: SerialDescriptor, index: Int, value: Short) {
125+
bufferEncoding(descriptor, index) {
126+
compositeEncoderDelegate.encodeShortElement(descriptor, index, value)
127+
}
128+
}
129+
130+
override fun encodeStringElement(descriptor: SerialDescriptor, index: Int, value: String) {
131+
bufferEncoding(descriptor, index) {
132+
compositeEncoderDelegate.encodeStringElement(descriptor, index, value)
133+
}
134+
}
135+
136+
override fun encodeInlineElement(descriptor: SerialDescriptor, index: Int): Encoder {
137+
return BufferingInlineEncoder(descriptor, index)
138+
}
139+
140+
override fun shouldEncodeElementDefault(descriptor: SerialDescriptor, index: Int): Boolean {
141+
return compositeEncoderDelegate.shouldEncodeElementDefault(descriptor, index)
142+
}
143+
144+
private inner class BufferingInlineEncoder(
145+
private val descriptor: SerialDescriptor,
146+
private val elementIndex: Int,
147+
) : Encoder {
148+
private var encodeNotNullMarkCalled = false
149+
150+
override val serializersModule: SerializersModule
151+
get() = this@ReorderingCompositeEncoder.serializersModule
152+
153+
private fun bufferEncoding(encoder: Encoder.() -> Unit) {
154+
bufferEncoding(descriptor, elementIndex) {
155+
compositeEncoderDelegate.encodeInlineElement(descriptor, elementIndex).apply {
156+
if (encodeNotNullMarkCalled) {
157+
encodeNotNullMark()
158+
}
159+
encoder()
160+
}
161+
}
162+
}
163+
164+
override fun encodeNotNullMark() {
165+
encodeNotNullMarkCalled = true
166+
}
167+
168+
override fun <T : Any> encodeNullableSerializableValue(serializer: SerializationStrategy<T>, value: T?) {
169+
bufferEncoding { encodeNullableSerializableValue(serializer, value) }
170+
}
171+
172+
override fun <T> encodeSerializableValue(serializer: SerializationStrategy<T>, value: T) {
173+
bufferEncoding { encodeSerializableValue(serializer, value) }
174+
}
175+
176+
override fun encodeBoolean(value: Boolean) {
177+
bufferEncoding { encodeBoolean(value) }
178+
}
179+
180+
override fun encodeByte(value: Byte) {
181+
bufferEncoding { encodeByte(value) }
182+
}
183+
184+
override fun encodeChar(value: Char) {
185+
bufferEncoding { encodeChar(value) }
186+
}
187+
188+
override fun encodeDouble(value: Double) {
189+
bufferEncoding { encodeDouble(value) }
190+
}
191+
192+
override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) {
193+
bufferEncoding { encodeEnum(enumDescriptor, index) }
194+
}
195+
196+
override fun encodeFloat(value: Float) {
197+
bufferEncoding { encodeFloat(value) }
198+
}
199+
200+
override fun encodeInt(value: Int) {
201+
bufferEncoding { encodeInt(value) }
202+
}
203+
204+
override fun encodeLong(value: Long) {
205+
bufferEncoding { encodeLong(value) }
206+
}
207+
208+
@ExperimentalSerializationApi
209+
override fun encodeNull() {
210+
bufferEncoding { encodeNull() }
211+
}
212+
213+
override fun encodeShort(value: Short) {
214+
bufferEncoding { encodeShort(value) }
215+
}
216+
217+
override fun encodeString(value: String) {
218+
bufferEncoding { encodeString(value) }
219+
}
220+
221+
override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
222+
invalidCall("beginStructure")
223+
}
224+
225+
override fun encodeInline(descriptor: SerialDescriptor): Encoder {
226+
invalidCall("encodeInline")
227+
}
228+
229+
private fun invalidCall(methodName: String): Nothing {
230+
// 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
231+
throw UnsupportedOperationException("$methodName should not be called when reordering fields, as it should be done by encodeSerializableValue or encodeNullableSerializableValue")
232+
}
233+
}
234+
}
235+
236+
/**
237+
* Encodes the [structureDescriptor] elements in a specific order provided by [elementIndexMapper].
238+
*
239+
* @param structureDescriptor descriptor of the structure being encoded and reordered
240+
* @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.
241+
*/
242+
@ExperimentalSerializationApi
243+
public fun CompositeEncoder.encodeReorderingElements(
244+
structureDescriptor: SerialDescriptor,
245+
elementIndexMapper: (SerialDescriptor, Int) -> Int,
246+
): CompositeEncoder = ReorderingCompositeEncoder(structureDescriptor, this, elementIndexMapper)

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

+72
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
/*
2+
* Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
3+
*/
4+
5+
package kotlinx.serialization.encoding
6+
7+
import kotlinx.serialization.*
8+
import kotlinx.serialization.descriptors.*
9+
import kotlinx.serialization.modules.*
10+
import kotlin.jvm.*
11+
import kotlin.test.*
12+
13+
class ReorderingCompositeEncoderTest {
14+
@Test
15+
fun shouldReorderWell() {
16+
val first = 42
17+
val second = "string"
18+
val third = true
19+
val value = OuterToBeReordered(Middle(Inner(second, third)), first)
20+
21+
val encoder = ReorderingEncoder().apply {
22+
encodeSerializableValue(OuterToBeReordered.serializer(), value)
23+
}
24+
25+
assertContentEquals(actual = encoder.encodedValues, expected = listOf(first, second, third))
26+
}
27+
28+
private class ReorderingEncoder(
29+
val encodedValues: MutableList<Any?> = mutableListOf()
30+
) : AbstractEncoder() {
31+
override val serializersModule: SerializersModule
32+
get() = EmptySerializersModule()
33+
34+
override fun encodeValue(value: Any) {
35+
encodedValues.add(value)
36+
}
37+
38+
override fun encodeNull() {
39+
encodedValues.add(null)
40+
}
41+
42+
override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
43+
return BasicCompositeEncoder().encodeReorderingElements(descriptor) { _, index ->
44+
// invert fields
45+
if (index == 0) 1 else 0
46+
}
47+
}
48+
49+
private inner class BasicCompositeEncoder : AbstractEncoder() {
50+
override val serializersModule: SerializersModule
51+
get() = EmptySerializersModule()
52+
53+
override fun encodeValue(value: Any) {
54+
encodedValues.add(value)
55+
}
56+
57+
override fun encodeNull() {
58+
encodedValues.add(null)
59+
}
60+
}
61+
}
62+
63+
@Serializable
64+
private data class OuterToBeReordered(val a: Middle, val b: Int)
65+
66+
@JvmInline
67+
@Serializable
68+
private value class Middle(val i: Inner)
69+
70+
@Serializable
71+
private data class Inner(val c: String, val d: Boolean)
72+
}

0 commit comments

Comments
 (0)