How to deserialize List<Any>?

[StefMa]

I have the following YAML structure:

---
- - :permit
  - MIT
  - :who: stranger
    :why:
    :versions: []
    :when: 2023-07-27 07:50:57.411184000 Z
- - :permit
  - Apache 2.0
  - :who: stranger
    :why:
    :versions: []
    :when: 2023-07-27 07:51:14.222256000 Z

This is the license file from the LicenseFinder project.
I can't change it.

If I get it correctly, this YAML is basically a List<List<Any>>
The first two items in the second list are an String (:permit & MIT/Apache 2.0), but the third one is an Object.

We tried different things to create our own Serializer, but the closest what we got is this one:

val fromString = Yaml.default.decodeFromString(
    ListSerializer(
        LicenseEntrySerializer()
    ),
    File("/path/to/the/license_finder_decisions.yml").readText(),
)

class LicenseEntrySerializer: KSerializer<List<String>> {
    override val descriptor: SerialDescriptor = ListSerializer(String.serializer()).descriptor

    override fun deserialize(decoder: Decoder): List<String> {
        val input = decoder.beginStructure(descriptor)

        input.decodeElementIndex(descriptor)
        val decision = input.decodeStringElement(descriptor, 0)

        input.decodeElementIndex(descriptor)
        val name = input.decodeStringElement(descriptor, 1)

        input.endStructure(descriptor)

        return listOf(decision, name)
    }

    override fun serialize(encoder: Encoder, value: List<String>) {
        // We don't need it yet
    }
}

We basically just asssume that the order of the YAML is stable, parsing the first two String (which are important for us), and ignoring the object.

However, I don't see any good solution (yet) to return an "nice Object" instead.

Can someone help here?

In best case the serializer return something like this

data class License(
    val decision: String
    val name: String
    val info: Info
)

data class Info(
    val who: String,
    val why: String,
    val versions: List<String>,
    val when: Instant // Or some other Date type 🙃 
)

So basically the License data class only that contain all the information from the parsing file.

I appreciate any help.

Update:

By the way, the library throws the following error in case I use "an Object" (the License class from above) instead of an List:

Exception in thread "main" IncorrectTypeException at [0] on line 2, column 3: Expected an object, but got a list
	at com.charleskorn.kaml.YamlInput$Companion.createFor$kaml(YamlInput.kt:58)
	at com.charleskorn.kaml.YamlListInput.decodeElementIndex(YamlListInput.kt:38)
	at kotlinx.serialization.internal.AbstractCollectionSerializer.merge(CollectionSerializers.kt:34)
	at kotlinx.serialization.internal.AbstractCollectionSerializer.deserialize(CollectionSerializers.kt:43)
	at kotlinx.serialization.encoding.Decoder$DefaultImpls.decodeSerializableValue(Decoding.kt:257)
	at kotlinx.serialization.encoding.AbstractDecoder.decodeSerializableValue(AbstractDecoder.kt:16)
	at com.charleskorn.kaml.YamlInput.decodeSerializableValue(YamlInput.kt:104)
	at com.charleskorn.kaml.Yaml.decodeFromReader(Yaml.kt:54)
	at com.charleskorn.kaml.Yaml.decodeFromString(Yaml.kt:43)
	at ReaderKt.loadDependencyLicenses(Reader.kt:28)
	at ReaderKt.main(Reader.kt:22)
	at ReaderKt.main(Reader.kt)

[charleskorn]

You're on the right track the idea to use a custom serializer - kotlinx.serialization won't support this unusual structure out of the box.

However, I don't see any good solution (yet) to return an "nice Object" instead.

You'll need to change the signature of the custom serializer to return a License type:

-class LicenseEntrySerializer: KSerializer<List<String>> {
+class LicenseEntrySerializer: KSerializer<License> {

And then adjust the implementation of deserialize accordingly.

You should be able to use kotlinx.serialization's default serializer for the Info type from the custom serializer for License, but you'll need to explicitly set the property names, for example:

data class Info(
    @SerialName(":who") val who: String,
    @SerialName(":why") val why: String,
    @SerialName(":versions") val versions: List<String>,
    @SerialName(":when") val when: Instant // Or some other Date type 🙃 
)

Hope that helps!

[StefMa]

Thanks for the reply @charleskorn!
That pushed us into the right direction I guess.
We finally managed to have a nice License object that contains a Info object 🥳
We just have to a "second" SerialDescriptor to the LicenseEntrySerializer that is able to deserialize the Info object:

class LicenseEntrySerializer: KSerializer<List<String>> {
    override val descriptor: SerialDescriptor = ListSerializer(String.serializer()).descriptor
    // Added the "child" SerialDescriptor
    private val infoMapDescriptor: SerialDescriptor = ListSerializer(Info.serializer()).descriptor

    override fun deserialize(decoder: Decoder): LicenseEntry {
        // Code from above..
        // Use the new MapDescriptor to deseriazlise the info object
        input.decodeElementIndex(infoMapDescriptor)
        val info = input.decodeSerializableElement(
            infoMapDescriptor,
            index = 2,
            object : DeserializationStrategy<Info> {
                override val descriptor: SerialDescriptor = Info.serializer().descriptor
                override fun deserialize(decoder: Decoder): Info = decoder.decodeSerializableValue(Info.serializer())
            },
        )
        //...
    }
}