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
|
/*
* Copyright 2018 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package kotlinx.serialization.internal
import kotlinx.serialization.*
import kotlin.reflect.KClass
sealed class PrimitiveDescriptor(override val name: String, override val kind: PrimitiveKind): SerialDescriptor {
private fun error(): Nothing = throw IllegalStateException("Primitives does not have elements")
final override fun getElementName(index: Int): String = error()
final override fun getElementIndex(name: String): Int = error()
final override fun isElementOptional(index: Int): Boolean = error()
final override fun getElementDescriptor(index: Int): SerialDescriptor = error()
override fun toString(): String = name
}
object IntDescriptor: PrimitiveDescriptor("kotlin.Int", PrimitiveKind.INT) // or just "Int"?
object UnitDescriptor: PrimitiveDescriptor("kotlin.Unit", PrimitiveKind.UNIT)
object BooleanDescriptor: PrimitiveDescriptor("kotlin.Boolean", PrimitiveKind.BOOLEAN)
object ByteDescriptor: PrimitiveDescriptor("kotlin.Byte", PrimitiveKind.BYTE)
object ShortDescriptor: PrimitiveDescriptor("kotlin.Short", PrimitiveKind.SHORT)
object LongDescriptor: PrimitiveDescriptor("kotlin.Long", PrimitiveKind.LONG)
object FloatDescriptor: PrimitiveDescriptor("kotlin.Float", PrimitiveKind.FLOAT)
object DoubleDescriptor: PrimitiveDescriptor("kotlin.Double", PrimitiveKind.DOUBLE)
object CharDescriptor: PrimitiveDescriptor("kotlin.Char", PrimitiveKind.CHAR)
object StringDescriptor: PrimitiveDescriptor("kotlin.String", PrimitiveKind.STRING)
object UnitSerializer : KSerializer<Unit> {
override val descriptor: SerialDescriptor = UnitDescriptor
override fun serialize(encoder: Encoder, obj: Unit) = encoder.encodeUnit()
override fun deserialize(decoder: Decoder): Unit = decoder.decodeUnit()
}
object BooleanSerializer : KSerializer<Boolean> {
override val descriptor: SerialDescriptor = BooleanDescriptor
override fun serialize(encoder: Encoder, obj: Boolean) = encoder.encodeBoolean(obj)
override fun deserialize(decoder: Decoder): Boolean = decoder.decodeBoolean()
}
object ByteSerializer : KSerializer<Byte> {
override val descriptor: SerialDescriptor = ByteDescriptor
override fun serialize(encoder: Encoder, obj: Byte) = encoder.encodeByte(obj)
override fun deserialize(decoder: Decoder): Byte = decoder.decodeByte()
}
object ShortSerializer : KSerializer<Short> {
override val descriptor: SerialDescriptor = ShortDescriptor
override fun serialize(encoder: Encoder, obj: Short) = encoder.encodeShort(obj)
override fun deserialize(decoder: Decoder): Short = decoder.decodeShort()
}
object IntSerializer : KSerializer<Int> {
override val descriptor: SerialDescriptor = IntDescriptor
override fun serialize(encoder: Encoder, obj: Int) = encoder.encodeInt(obj)
override fun deserialize(decoder: Decoder): Int = decoder.decodeInt()
}
object LongSerializer : KSerializer<Long> {
override val descriptor: SerialDescriptor = LongDescriptor
override fun serialize(encoder: Encoder, obj: Long) = encoder.encodeLong(obj)
override fun deserialize(decoder: Decoder): Long = decoder.decodeLong()
}
object FloatSerializer : KSerializer<Float> {
override val descriptor: SerialDescriptor = FloatDescriptor
override fun serialize(encoder: Encoder, obj: Float) = encoder.encodeFloat(obj)
override fun deserialize(decoder: Decoder): Float = decoder.decodeFloat()
}
object DoubleSerializer : KSerializer<Double> {
override val descriptor: SerialDescriptor = DoubleDescriptor
override fun serialize(encoder: Encoder, obj: Double) = encoder.encodeDouble(obj)
override fun deserialize(decoder: Decoder): Double = decoder.decodeDouble()
}
object CharSerializer : KSerializer<Char> {
override val descriptor: SerialDescriptor = CharDescriptor
override fun serialize(encoder: Encoder, obj: Char) = encoder.encodeChar(obj)
override fun deserialize(decoder: Decoder): Char = decoder.decodeChar()
}
object StringSerializer : KSerializer<String> {
override val descriptor: SerialDescriptor = StringDescriptor
override fun serialize(encoder: Encoder, obj: String) = encoder.encodeString(obj)
override fun deserialize(decoder: Decoder): String = decoder.decodeString()
}
@Suppress("UNCHECKED_CAST")
fun <T : Any> KClass<T>.defaultSerializer(): KSerializer<T>? = when (this) {
String::class -> StringSerializer
Char::class -> CharSerializer
Double::class -> DoubleSerializer
Float::class -> FloatSerializer
Long::class -> LongSerializer
Int::class -> IntSerializer
Short::class -> ShortSerializer
Byte::class -> ByteSerializer
Boolean::class -> BooleanSerializer
Unit::class -> UnitSerializer
else -> null
} as KSerializer<T>?
|
