kotlin: nested polymorphic serialization with generics - json

Question

I want to serialize Map<String, Any> and one of the values type is Pair<Int, Int>.
How to register the Pair as polymorphic subclass for that?
val module = SerializersModule {
polymorphic(Any::class) {
subclass(Int::class, PolymorphicPrimitiveSerializer(Int.serializer()))
subclass(String::class, PolymorphicPrimitiveSerializer(String.serializer()))
subclass(Pair::class, PolymorphicSerializer(Pair::class))
}
}
val format = Json { serializersModule = module }
val mm = mapOf<String, Any>()
.plus("int-int pair") to (5 to 10))
val jsoned = format.encodeToString(mm)
val mmDecoded = format.decodeFromString(jsoned)
require(mm==mmDecoded)
should encode to json like:
[{"first": "int-int pair",
"second":{"type": "Pair", "value":
{"first": {"type": Int, "value":5}, "second": {"type":Int, "value": 10}}}}]
But produce the following error:
Exception in thread "main" java.lang.ExceptionInInitializerError
Caused by: java.lang.IllegalArgumentException: Serializer for Pair
can't be registered as a subclass for polymorphic serialization
because its kind OPEN is not concrete. To work with multiple
hierarchies, register it as a base class. at
kotlinx.serialization.json.internal.PolymorphismValidator.checkKind(PolymorphismValidator.kt:41)
at
kotlinx.serialization.json.internal.PolymorphismValidator.polymorphic(PolymorphismValidator.kt:31)
at
kotlinx.serialization.modules.SerialModuleImpl.dumpTo(SerializersModule.kt:189)
at
kotlinx.serialization.json.JsonImpl.validateConfiguration(Json.kt:358)
at kotlinx.serialization.json.JsonImpl.(Json.kt:352) at
kotlinx.serialization.json.JsonKt.Json(Json.kt:189) at
kotlinx.serialization.json.JsonKt.Json$default(Json.kt:185) at
MainKt.(Main.kt:143)

Answer 1

I could not make it work with polymorphic subclasses, but I don't think that feature is intended for use with Any and primitives anyway (see this question). A custom serializer seems like a more appropriate and simpler solution and unlike the polymorphic serialization, it doesn't require too much custom serializer code:
#ExperimentalSerializationApi
class DynamicLookupSerializer: KSerializer<Any> {
override val descriptor: SerialDescriptor = ContextualSerializer(Any::class, null, emptyArray()).descriptor
#OptIn(InternalSerializationApi::class)
override fun serialize(encoder: Encoder, value: Any) {
val actualSerializer = encoder.serializersModule.getContextual(value::class) ?: value::class.serializer()
encoder.encodeSerializableValue(actualSerializer as KSerializer<Any>, value)
}
override fun deserialize(decoder: Decoder): Any {
return try {
PairSerializer(Int.serializer(), Int.serializer()).deserialize(decoder)
} catch (e: Throwable) {
try {
decoder.decodeInt()
} catch (e: Throwable) {
decoder.decodeString()
}
}
}
}
val module = SerializersModule {
contextual(Any::class, DynamicLookupSerializer())
contextual(Pair::class) {
PairSerializer(Int.serializer(), Int.serializer())
}
}
val format = Json { serializersModule = module }
val mm = mapOf<String, Any>()
.plus("int-int pair" to (5 to 10))
.plus("int" to 6)
.plus("string" to "some string")
.plus("another-int" to 86248726)
.plus("another-pair" to (56 to 961))
val jsoned = format.encodeToString(mm)
println(jsoned)
val mmDecoded = format.decodeFromString<Map<String, Any>>(jsoned)
require(mm==mmDecoded)
In this custom serializer, we find the actual serializer for value: Any when serializing by looking it up via its class (value::class). As a result, PairSerializer(Int.serializer(), Int.serializer()) has to be registered too so that it will be found in DynamicLookupSerializer.serialize. When deserializing, we try the supported serializers one by one (string, int, and pair of ints).
I do realize that this is not the nicest solution due to the try-catches but it does work and it's simple enough.

Answer 2

I solved it by providing custom Polymorphic serializer similar to how I serialized the map:
https://github.com/assafshouval/PolymorphicMapSerializer/blob/master/src/main/kotlin/Main.kt

Answer 3

import kotlinx.serialization.builtins.*
val pairAnyAnySerializer = PairSerializer(
PolymorphicSerializer(Any::class), PolymorphicSerializer(Any::class)
) as <KSerializer<Pair<*,*>>>()
and for every type that is defined in the serializers module for polymorphic serializatin of Any it will serialize/deserialze correct.
val json = Json {
serializersModule = SerializersModule {
polymorphic(Any::class) {
subclass(String::class, PolymorphicPrimitiveSerializer(String.serializer()))
subclass(Int::class, PolymorphicPrimitiveSerializer(Int.serializer()))
}
}
}