@XmlClassDiscriminator

[mgroth0]

@JsonClassDiscriminator allows for a custom type discriminator for one type hierarchy. Is there an equivalent feature for Xml? If not, I suggest it.

[pdvrieze]

This is supported through the policy. For the default policy you can set it using the typeDiscriminatorName property. The general case is the polymorphicDiscriminatorName function that allows this to be specified per item. This can be implemented in any way to determine the discriminator to use, including an annotation.

[mgroth0]

@pdvrieze Thank you. I am actually struggling in general with polymorphism. I've re-read the README many times and can not wrap my head around it.

How do we solve this simple case?

    private fun testFullCircle(
        xml: String,
        expected: RootObject
    ) {
        val format = XML {
            defaultPolicy {
                autoPolymorphic = true
                typeDiscriminatorName = QName("species")
            }
        }
        val root = format.decodeFromString<RootObject>(xml)
        assertEquals(expected, root)
        val encoded = format.encodeToString(root)
        val root2 = format.decodeFromString<RootObject>(encoded)
        assertEquals(expected, root2)
    }


    @Test
    fun decodePolymorphic() {

        testFullCircle(
            xml = """
            <?xml version='1.0' encoding='UTF-8'?>
            <root>
                <animal>
                    <species>spider</species>
                    <numberOfEyes>10</numberOfEyes>
                </animal>
            </root>
        """.trimIndent(),
            expected = RootObject(Spider(numberOfEyes = 10))
        )
        testFullCircle(
            xml = """
            <?xml version='1.0' encoding='UTF-8'?>
            <root>
                <animal>
                    <species>cat</species>
                    <numberOfWhiskers>12</numberOfWhiskers>
                </animal>
            </root>
        """.trimIndent(),
            expected = RootObject(Cat(numberOfWhiskers = 12))
        )
    }

    @XmlSerialName("root")
    @Serializable
    data class RootObject(
        @XmlSerialName("animal")
        @XmlElement val animal: Animal,
    )

    @Serializable
    @XmlSerialName("animal")
    sealed interface Animal

    @Serializable
    @SerialName("spider")
    data class Spider(@XmlElement val numberOfEyes: Int) : Animal

    @Serializable
    @SerialName("cat")
    data class Cat(@XmlElement val numberOfWhiskers: Int) : Animal

How do we decode this? I am trying many different things, but cannot figure it out.

[mgroth0]

I am totally confused about where I should be trying to do this with autoPolymorphic set to true or false.

[mgroth0]

Either way I get errors. I cannot pass this test.

[mgroth0]

Note I've edited the test code in the comment above many times. It should be good now as it is.

[mgroth0]

For context, I am working with a dataset that has polymorphism like this. I currently only need to decode this database, so encoding with this format is optional for me.

[pdvrieze]

I haven't seen this particular case before, the type discriminator has to be an attribute as there is an order issue. Probably the best way to do this is to transform the xml (possibly using DOM that you then feed into a delegate (de)serializer)

[mgroth0]

Ok! I got this working for the simple case as you suggested.

fun String.transformXMLTagToAttribute(
    tagName: String
): String {
    /*Parse the input XML string into a DOM document*/
    val factory = DocumentBuilderFactory.newInstance()
    val builder = factory.newDocumentBuilder()
    val doc = builder.parse(InputSource(StringReader(this)))

    /*Get a list of elements with the given tagName*/
    val elements = doc.getElementsByTagName(tagName)

    /*Iterate through the elements and perform the transformation*/
    for (i in 0 until elements.length) {
        val element = elements.item(i) as Element
        val textContent = element.textContent
        val parent = element.parentNode as Element

        /*Remove the element*/
        parent.removeChild(element)

        /*Add an attribute to the parent element*/
        parent.setAttribute(tagName, textContent)
    }

    /*Serialize the modified DOM document back to an XML string*/
    val transformerFactory = TransformerFactory.newInstance()
    val transformer = transformerFactory.newTransformer()
    val writer = StringWriter()
    transformer.transform(DOMSource(doc), StreamResult(writer))

    return writer.toString()
}

      testFullCircle(
            xml = """
            <root>
                <animal>
                    <species>spider</species>
                    <numberOfEyes>10</numberOfEyes>
                </animal>
            </root>
        """.transformXMLTagToAttribute("species"),
            expected = RootObject(Spider(numberOfEyes = 10))
        )

[mgroth0]

The tests all pass. However, in the real world the XML files are gigantic. Each file multiple megabytes and there are thousands of files.

Can I ask your advice for how I can apply this transformation only in a specific location in the document tree so that it doesn't parse the rest of the tree twice?

I am looking at https://github.com/pdvrieze/xmlutil/blob/master/examples/DYNAMIC_TAG_NAMES.md . If I understand correctly, this is the most relevant documentation for what I am trying to do.

The code there seems very complex relative to what I am trying to do, and also that code doesn't seem to be for polymorphic types which I think might have some different rules. What are your thoughts? Is the best I can do to try to adapt that guide to my use case?

[pdvrieze]

The dynamic tag names example is a different approach that could be taken. For your case the biggest challenge is that the structure prevents a single pass approach (you need memory that is not just for the current attributes). There are different ways to do this. DOM is one, another approach could be to use CompactFragment (which rather than a dom node stores the raw text as well as needed namespace declarations).

The way I would approach your problem is to have the custom serializer for the Animal class. This custom serializer would in encode/decode detect the xml format and special case this. In this special case for deserialization you do the following:

1. Read the content of the <animal> tag into a compact fragment (including the tag itself) - there is a function around that does this.
2. Using one of the ways to get an XmlReader (eg. XmlStreaming.newReader) that you read the type from.
3. Using the value of the type determine the correct deserializer (this means you don't need to use the SerializersModule, but you actually could)
4. Create a delegate format that now uses the type specific deserializer to deserialize. You need to either configure it to ignore the species tag or to add a filter that removes it (you can access depth to make this work). Alternatively you could have species also be a property of each child type (field property in the base Animal).

Serialization is a bit tricky. You will need a nested format with a special writer that injects the <species> tag (at latest before closing the <animal> tag).

Depending on your data format it may be easier to just use a serial delegate that supports all needed child elements/attributes (optionally), and then is used using regular Kotlin to initialise the correct Animal subclass (and can be constructed from any of the subclasses) - this does imply though that you can control all members of all polymorphic children (none are defined out of the module) and there are no incompatible overlaps.