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
|
/*
* Copyright 2017-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
*/
package kotlinx.serialization
import kotlinx.serialization.modules.EmptyModule
import kotlinx.serialization.modules.SerialModule
abstract class ElementValueEncoder : Encoder, CompositeEncoder {
override val context: SerialModule
get() = EmptyModule
override fun beginStructure(descriptor: SerialDescriptor, vararg typeSerializers: KSerializer<*>): CompositeEncoder {
return this
}
/**
* Always invoked before writing each element to determine if it should be encoded.
*
* @return True if value should be encoded, false otherwise
*/
open fun encodeElement(desc: SerialDescriptor, index: Int): Boolean = true
/**
* Encodes that following value is not null.
* No-op by default.
*/
override fun encodeNotNullMark() {}
open fun encodeValue(value: Any): Unit
= throw SerializationException("Non-serializable ${value::class} is not supported by ${this::class} encoder")
override fun encodeNull() {
throw SerializationException("null is not supported")
}
override fun encodeUnit() {
val encoder = beginStructure(UnitSerializer.descriptor); encoder.endStructure(UnitSerializer.descriptor)
}
override fun encodeBoolean(value: Boolean) = encodeValue(value)
override fun encodeByte(value: Byte) = encodeValue(value)
override fun encodeShort(value: Short) = encodeValue(value)
override fun encodeInt(value: Int) = encodeValue(value)
override fun encodeLong(value: Long) = encodeValue(value)
override fun encodeFloat(value: Float) = encodeValue(value)
override fun encodeDouble(value: Double) = encodeValue(value)
override fun encodeChar(value: Char) = encodeValue(value)
override fun encodeString(value: String) = encodeValue(value)
override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) = encodeValue(index)
// Delegating implementation of CompositeEncoder
final override fun encodeNonSerializableElement(descriptor: SerialDescriptor, index: Int, value: Any) { if (encodeElement(descriptor, index)) encodeValue(value) }
final override fun encodeUnitElement(descriptor: SerialDescriptor, index: Int) { if (encodeElement(descriptor, index)) encodeUnit() }
final override fun encodeBooleanElement(descriptor: SerialDescriptor, index: Int, value: Boolean) { if (encodeElement(descriptor, index)) encodeBoolean(value) }
final override fun encodeByteElement(descriptor: SerialDescriptor, index: Int, value: Byte) { if (encodeElement(descriptor, index)) encodeByte(value) }
final override fun encodeShortElement(descriptor: SerialDescriptor, index: Int, value: Short) { if (encodeElement(descriptor, index)) encodeShort(value) }
final override fun encodeIntElement(descriptor: SerialDescriptor, index: Int, value: Int) { if (encodeElement(descriptor, index)) encodeInt(value) }
final override fun encodeLongElement(descriptor: SerialDescriptor, index: Int, value: Long) { if (encodeElement(descriptor, index)) encodeLong(value) }
final override fun encodeFloatElement(descriptor: SerialDescriptor, index: Int, value: Float) { if (encodeElement(descriptor, index)) encodeFloat(value) }
final override fun encodeDoubleElement(descriptor: SerialDescriptor, index: Int, value: Double) { if (encodeElement(descriptor, index)) encodeDouble(value) }
final override fun encodeCharElement(descriptor: SerialDescriptor, index: Int, value: Char) { if (encodeElement(descriptor, index)) encodeChar(value) }
final override fun encodeStringElement(descriptor: SerialDescriptor, index: Int, value: String) { if (encodeElement(descriptor, index)) encodeString(value) }
final override fun <T : Any?> encodeSerializableElement(desc: SerialDescriptor, index: Int, serializer: SerializationStrategy<T>, value: T) {
if (encodeElement(desc, index))
encodeSerializableValue(serializer, value)
}
final override fun <T : Any> encodeNullableSerializableElement(desc: SerialDescriptor, index: Int, serializer: SerializationStrategy<T>, value: T?) {
if (encodeElement(desc, index))
encodeNullableSerializableValue(serializer, value)
}
}
abstract class ElementValueDecoder : Decoder, CompositeDecoder {
override val context: SerialModule
get() = EmptyModule
override val updateMode: UpdateMode = UpdateMode.UPDATE
// ------- implementation API -------
override fun decodeNotNullMark(): Boolean = true
override fun decodeNull(): Nothing? = null
open fun decodeValue(): Any = throw SerializationException("${this::class} can't retrieve untyped values")
override fun decodeUnit() {
val reader = beginStructure(UnitSerializer.descriptor); reader.endStructure(UnitSerializer.descriptor)
}
override fun decodeBoolean(): Boolean = decodeValue() as Boolean
override fun decodeByte(): Byte = decodeValue() as Byte
override fun decodeShort(): Short = decodeValue() as Short
override fun decodeInt(): Int = decodeValue() as Int
override fun decodeLong(): Long = decodeValue() as Long
override fun decodeFloat(): Float = decodeValue() as Float
override fun decodeDouble(): Double = decodeValue() as Double
override fun decodeChar(): Char = decodeValue() as Char
override fun decodeString(): String = decodeValue() as String
override fun decodeEnum(enumDescriptor: SerialDescriptor): Int = decodeValue() as Int
// Delegating implementation of CompositeEncoder
override fun beginStructure(desc: SerialDescriptor, vararg typeParams: KSerializer<*>): CompositeDecoder {
return this
}
final override fun decodeUnitElement(desc: SerialDescriptor, index: Int) = decodeUnit()
final override fun decodeBooleanElement(descriptor: SerialDescriptor, index: Int): Boolean = decodeBoolean()
final override fun decodeByteElement(descriptor: SerialDescriptor, index: Int): Byte = decodeByte()
final override fun decodeShortElement(descriptor: SerialDescriptor, index: Int): Short = decodeShort()
final override fun decodeIntElement(desc: SerialDescriptor, index: Int): Int = decodeInt()
final override fun decodeLongElement(descriptor: SerialDescriptor, index: Int): Long = decodeLong()
final override fun decodeFloatElement(descriptor: SerialDescriptor, index: Int): Float = decodeFloat()
final override fun decodeDoubleElement(desc: SerialDescriptor, index: Int): Double = decodeDouble()
final override fun decodeCharElement(descriptor: SerialDescriptor, index: Int): Char = decodeChar()
final override fun decodeStringElement(descriptor: SerialDescriptor, index: Int): String = decodeString()
final override fun <T: Any?> decodeSerializableElement(desc: SerialDescriptor, index: Int, deserializer: DeserializationStrategy<T>): T =
decodeSerializableValue(deserializer)
final override fun <T: Any> decodeNullableSerializableElement(desc: SerialDescriptor, index: Int, deserializer: DeserializationStrategy<T?>): T? =
decodeNullableSerializableValue(deserializer)
final override fun <T> updateSerializableElement(desc: SerialDescriptor, index: Int, deserializer: DeserializationStrategy<T>, old: T): T =
updateSerializableValue(deserializer, old)
final override fun <T: Any> updateNullableSerializableElement(desc: SerialDescriptor, index: Int, deserializer: DeserializationStrategy<T?>, old: T?): T? =
updateNullableSerializableValue(deserializer, old)
}
|
