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
|
/*
* Copyright 2017-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
*/
package org.jetbrains.kotlinx.serialization.config
import com.typesafe.config.*
import kotlinx.serialization.*
import kotlinx.serialization.CompositeDecoder.Companion.READ_DONE
import kotlinx.serialization.modules.*
private val SerialKind.listLike get() = this == StructureKind.LIST || this is PolymorphicKind
private val SerialKind.objLike get() = this == StructureKind.CLASS || this == StructureKind.OBJECT
class ConfigParser(context: SerialModule = EmptyModule): AbstractSerialFormat(context) {
@ImplicitReflectionSerializer
inline fun <reified T : Any> parse(conf: Config): T = parse(conf, context.getContextualOrDefault(T::class))
fun <T> parse(conf: Config, deserializer: DeserializationStrategy<T>): T = ConfigReader(conf).decode(deserializer)
private abstract inner class ConfigConverter<T> : TaggedDecoder<T>() {
override val context: SerialModule
get() = this@ConfigParser.context
abstract fun getTaggedConfigValue(tag: T): ConfigValue
private inline fun <reified E : Any> validateAndCast(tag: T, wrappedType: ConfigValueType): E {
val cfValue = getTaggedConfigValue(tag)
if (cfValue.valueType() != wrappedType) throw SerializationException("${cfValue.origin().description()} required to be a $wrappedType")
return cfValue.unwrapped() as E
}
private fun getTaggedNumber(tag: T) = validateAndCast<Number>(tag, ConfigValueType.NUMBER)
override fun decodeTaggedString(tag: T) = validateAndCast<String>(tag, ConfigValueType.STRING)
override fun decodeTaggedByte(tag: T): Byte = getTaggedNumber(tag).toByte()
override fun decodeTaggedShort(tag: T): Short = getTaggedNumber(tag).toShort()
override fun decodeTaggedInt(tag: T): Int = getTaggedNumber(tag).toInt()
override fun decodeTaggedLong(tag: T): Long = getTaggedNumber(tag).toLong()
override fun decodeTaggedFloat(tag: T): Float = getTaggedNumber(tag).toFloat()
override fun decodeTaggedDouble(tag: T): Double = getTaggedNumber(tag).toDouble()
override fun decodeTaggedUnit(tag: T) = Unit
override fun decodeTaggedChar(tag: T): Char {
val s = validateAndCast<String>(tag, ConfigValueType.STRING)
if (s.length != 1) throw SerializationException("String \"$s\" is not convertible to Char")
return s[0]
}
override fun decodeTaggedValue(tag: T): Any = getTaggedConfigValue(tag).unwrapped()
override fun decodeTaggedNotNullMark(tag: T) = getTaggedConfigValue(tag).valueType() != ConfigValueType.NULL
override fun decodeTaggedEnum(tag: T, enumDescription: SerialDescriptor): Int {
val s = validateAndCast<String>(tag, ConfigValueType.STRING)
return enumDescription.getElementIndexOrThrow(s)
}
}
private inner class ConfigReader(val conf: Config) : ConfigConverter<String>() {
private var ind = -1
override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
while (++ind < descriptor.elementsCount) {
val name = descriptor.getTag(ind)
if (conf.hasPathOrNull(name)) {
return ind
}
}
return READ_DONE
}
private fun composeName(parentName: String, childName: String) =
if (parentName.isEmpty()) childName else parentName + "." + childName
override fun SerialDescriptor.getTag(index: Int): String = composeName(
currentTagOrNull
?: "", getElementName(index)
)
override fun getTaggedConfigValue(tag: String): ConfigValue {
return conf.getValue(tag)
}
override fun decodeTaggedNotNullMark(tag: String): Boolean {
return !conf.getIsNull(tag)
}
override fun beginStructure(desc: SerialDescriptor, vararg typeParams: KSerializer<*>): CompositeDecoder =
when {
desc.kind.listLike -> ListConfigReader(conf.getList(currentTag))
desc.kind.objLike -> if (ind > -1) ConfigReader(conf.getConfig(currentTag)) else this
desc.kind == StructureKind.MAP -> MapConfigReader(conf.getObject(currentTag))
else -> this
}
}
private inner class ListConfigReader(private val list: ConfigList) : ConfigConverter<Int>() {
private var ind = -1
override fun beginStructure(desc: SerialDescriptor, vararg typeParams: KSerializer<*>): CompositeDecoder =
when {
desc.kind.listLike -> ListConfigReader(list[currentTag] as ConfigList)
desc.kind.objLike -> ConfigReader((list[currentTag] as ConfigObject).toConfig())
desc.kind == StructureKind.MAP -> MapConfigReader(list[currentTag] as ConfigObject)
else -> this
}
override fun SerialDescriptor.getTag(index: Int) = index
override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
ind++
return if (ind > list.size - 1) READ_DONE else ind
}
override fun getTaggedConfigValue(tag: Int): ConfigValue = list[tag]
}
private inner class MapConfigReader(map: ConfigObject) : ConfigConverter<Int>() {
private var ind = -1
private val keys: List<String>
private val values: List<ConfigValue>
init {
val entries = map.entries.toList() // to fix traversal order
keys = entries.map(MutableMap.MutableEntry<String, ConfigValue>::key)
values = entries.map(MutableMap.MutableEntry<String, ConfigValue>::value)
}
private val indexSize = values.size * 2
override fun beginStructure(desc: SerialDescriptor, vararg typeParams: KSerializer<*>): CompositeDecoder =
when {
desc.kind.listLike -> ListConfigReader(values[currentTag / 2] as ConfigList)
desc.kind.objLike -> ConfigReader((values[currentTag / 2] as ConfigObject).toConfig())
desc.kind == StructureKind.MAP -> MapConfigReader(values[currentTag / 2] as ConfigObject)
else -> this
}
override fun SerialDescriptor.getTag(index: Int) = index
override fun decodeElementIndex(descriptor: SerialDescriptor): Int {
ind++
return if (ind >= indexSize) READ_DONE else ind
}
override fun getTaggedConfigValue(tag: Int): ConfigValue {
val idx = tag / 2
return if (tag % 2 == 0) { // entry as string
ConfigValueFactory.fromAnyRef(keys[idx])
} else {
values[idx]
}
}
}
@Suppress("UNUSED")
companion object {
public fun <T> parse(conf: Config, serial: DeserializationStrategy<T>): T = ConfigParser().parse(conf, serial)
@ImplicitReflectionSerializer
public inline fun <reified T : Any> parse(conf: Config): T = ConfigParser().parse(conf, T::class.serializer())
}
}
|
