1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
package kotlinx.serialization.internal
import kotlinx.serialization.*
const val KEY_INDEX = 0
const val VALUE_INDEX = 1
sealed class KeyValueSerializer<K, V, R>(val kSerializer: KSerializer<K>, val vSerializer: KSerializer<V>) :
KSerializer<R> {
abstract override val descriptor: SerialDescriptor
abstract fun toResult(key: K, value: V): R
abstract val R.key: K
abstract val R.value: V
override fun serialize(encoder: Encoder, obj: R) {
@Suppress("NAME_SHADOWING")
val encoder = encoder.beginStructure(descriptor, kSerializer, vSerializer)
encoder.encodeSerializableElement(descriptor, KEY_INDEX, kSerializer, obj.key)
encoder.encodeSerializableElement(descriptor, VALUE_INDEX, vSerializer, obj.value)
encoder.endStructure(descriptor)
}
override fun deserialize(decoder: Decoder): R {
@Suppress("NAME_SHADOWING")
val input = decoder.beginStructure(descriptor, kSerializer, vSerializer)
var kSet = false
var vSet = false
var k: Any? = null
var v: Any? = null
mainLoop@ while (true) {
when (input.decodeElementIndex(descriptor)) {
CompositeDecoder.READ_ALL -> {
k = readKey(input)
kSet = true
v = readValue(input, k, kSet)
vSet = true
break@mainLoop
}
CompositeDecoder.READ_DONE -> {
break@mainLoop
}
KEY_INDEX -> {
k = readKey(input)
kSet = true
}
VALUE_INDEX -> {
v = readValue(input, k, kSet)
vSet = true
}
else -> throw SerializationException("Invalid index")
}
}
input.endStructure(descriptor)
if (!kSet) throw SerializationException("Required key is missing")
if (!vSet) throw SerializationException("Required value is missing")
@Suppress("UNCHECKED_CAST")
return toResult(k as K, v as V)
}
protected open fun readKey(decoder: CompositeDecoder): K {
return decoder.decodeSerializableElement(descriptor, KEY_INDEX, kSerializer)
}
protected open fun readValue(decoder: CompositeDecoder, k: Any?, kSet: Boolean): V {
return decoder.decodeSerializableElement(descriptor, VALUE_INDEX, vSerializer)
}
}
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
class MapEntryUpdatingSerializer<K, V>(mSerializer: MapEntrySerializer<K, V>, private val mapBuilder: MutableMap<K, V>) :
KeyValueSerializer<K, V, Map.Entry<K, V>>(mSerializer.kSerializer, mSerializer.vSerializer) {
override val descriptor = MapEntryClassDesc
override fun toResult(key: K, value: V): Map.Entry<K, V> = MapEntry(key, value)
override fun readValue(decoder: CompositeDecoder, k: Any?, kSet: Boolean): V {
if (!kSet) throw SerializationException("Key must be before value in serialization stream")
@Suppress("UNCHECKED_CAST")
val key = k as K
val v = if (mapBuilder.containsKey(key) && vSerializer.descriptor.kind !is PrimitiveKind) {
decoder.updateSerializableElement(descriptor, VALUE_INDEX, vSerializer, mapBuilder.getValue(key))
} else {
decoder.decodeSerializableElement(descriptor, VALUE_INDEX, vSerializer)
}
mapBuilder[key] = v
return v
}
override val Map.Entry<K, V>.key: K
get() = this.key
override val Map.Entry<K, V>.value: V
get() = this.value
}
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
class MapEntrySerializer<K, V>(kSerializer: KSerializer<K>, vSerializer: KSerializer<V>) :
KeyValueSerializer<K, V, Map.Entry<K, V>>(kSerializer, vSerializer) {
override val descriptor = MapEntryClassDesc
override fun toResult(key: K, value: V): Map.Entry<K, V> = MapEntry(key, value)
override val Map.Entry<K, V>.key: K
get() = this.key
override val Map.Entry<K, V>.value: V
get() = this.value
}
class PairSerializer<K, V>(kSerializer: KSerializer<K>, vSerializer: KSerializer<V>) :
KeyValueSerializer<K, V, Pair<K, V>>(kSerializer, vSerializer) {
override val descriptor = PairClassDesc
override fun toResult(key: K, value: V) = key to value
override val Pair<K, V>.key: K
get() = this.first
override val Pair<K, V>.value: V
get() = this.second
}
data class MapEntry<K, V>(override val key: K, override val value: V) : Map.Entry<K, V>
object MapEntryClassDesc : SerialClassDescImpl("kotlin.collections.Map.Entry") {
override val kind = StructureKind.MAP
init {
addElement("key")
addElement("value")
}
}
object PairClassDesc : SerialClassDescImpl("kotlin.Pair") {
init {
addElement("first")
addElement("second")
}
}
class TripleSerializer<A, B, C>(
private val aSerializer: KSerializer<A>,
private val bSerializer: KSerializer<B>,
private val cSerializer: KSerializer<C>
) : KSerializer<Triple<A, B, C>> {
object TripleDesc : SerialClassDescImpl("kotlin.Triple") {
init {
addElement("first")
addElement("second")
addElement("third")
}
}
override val descriptor: SerialDescriptor = TripleDesc
override fun serialize(encoder: Encoder, obj: Triple<A, B, C>) {
@Suppress("NAME_SHADOWING")
val encoder = encoder.beginStructure(descriptor, aSerializer, bSerializer, cSerializer)
encoder.encodeSerializableElement(descriptor, 0, aSerializer, obj.first)
encoder.encodeSerializableElement(descriptor, 1, bSerializer, obj.second)
encoder.encodeSerializableElement(descriptor, 2, cSerializer, obj.third)
encoder.endStructure(descriptor)
}
override fun deserialize(decoder: Decoder): Triple<A, B, C> {
@Suppress("NAME_SHADOWING")
val input = decoder.beginStructure(descriptor, aSerializer, bSerializer, cSerializer)
var aSet = false
var bSet = false
var cSet = false
var a: Any? = null
var b: Any? = null
var c: Any? = null
mainLoop@ while (true) {
when (input.decodeElementIndex(descriptor)) {
CompositeDecoder.READ_ALL -> {
a = input.decodeSerializableElement(descriptor, 0, aSerializer)
aSet = true
b = input.decodeSerializableElement(descriptor, 1, bSerializer)
bSet = true
c = input.decodeSerializableElement(descriptor, 2, cSerializer)
cSet = true
break@mainLoop
}
CompositeDecoder.READ_DONE -> {
break@mainLoop
}
0 -> {
a = input.decodeSerializableElement(descriptor, 0, aSerializer)
aSet = true
}
1 -> {
b = input.decodeSerializableElement(descriptor, 1, bSerializer)
bSet = true
}
2 -> {
c = input.decodeSerializableElement(descriptor, 2, cSerializer)
cSet = true
}
else -> throw SerializationException("Invalid index")
}
}
input.endStructure(descriptor)
if (!aSet) throw SerializationException("Required first is missing")
if (!bSet) throw SerializationException("Required second is missing")
if (!cSet) throw SerializationException("Required third is missing")
@Suppress("UNCHECKED_CAST")
return Triple(a as A, b as B, c as C)
}
}
|
