XmlUtil

A DynamicTagWriter is a custom XmlDelegatingWriter used during serialization to transform static tag names into dynamic ones (e.g., converting <TestElement> with id=1 into <Test_1>).

Key Responsibilities

• Tag Renaming: Overrides startTag and endTag to write the dynamic string (e.g., "Test_" + idValue) instead of the standard tag name.
• Attribute Filtering: Can be used to suppress specific attributes that are being moved from the element body into the tag name itself (e.g., ignoring the id attribute during the attribute() call so it doesn't appear twice).

internal class DynamicTagWriter(private val writer: XmlWriter, descriptor: XmlDescriptor, private val idValue: String) :
    XmlDelegatingWriter(writer) {
    
    override fun startTag(namespace: String?, localName: String, prefix: String?) {
        when (filterDepth) {
            0 -> super.startTag("", "Test_$idValue", "")
            else -> super.startTag(namespace, localName, prefix)
        }
    }

    override fun endTag(namespace: String?, localName: String, prefix: String?) {
        when (filterDepth) {
            1 -> super.endTag("", "Test_$idValue", "")
            else -> super.endTag(namespace, localName, prefix)
        }
    }
}

To implement a SOAP-compliant structure, use the @XmlSerialName annotation to define the namespace and the preferred prefix for the Envelope and Body elements.

In the provided pattern, the Envelope class acts as a generic wrapper. It uses a private Body class to ensure the SOAP standard requirement of a single wrapping element is met. The Envelope provides a public constructor that accepts the payload directly, hiding the internal Body implementation.

Key annotations:

• @XmlSerialName(name, namespace, prefix): Used on the Envelope class to set the SOAP envelope namespace (e.g., http://schemas.xmlsoap.org/soap/envelope/) and prefix (e.g., S).
• @Polymorphic: Used within the Body class to allow the content of the SOAP message to vary.

@Serializable
@XmlSerialName("Envelope", "http://schemas.xmlsoap.org/soap/envelope/", "S")
class Envelope<BODYTYPE> private constructor(
    private val body: Body<BODYTYPE>
) {
    constructor(data: BODYTYPE) : this(Body(data))
    val data: BODYTYPE get() = body.data

    @Serializable
    private data class Body<BODYTYPE>(@Polymorphic val data: BODYTYPE)
}

When defining the actual message content (the payload inside the SOAP Body), you can control namespaces at different levels:

1. Payload Namespace: Use @XmlSerialName on your result class (e.g., GeResult) to define its specific namespace and prefix (e.g., ns2).
2. Empty Namespaces for Primitives: If a property (like a code field) should reside in the empty/default namespace rather than inheriting the parent's namespace, use @XmlSerialName with empty strings for the namespace and prefix, and pair it with @XmlElement(true) to ensure it is serialized as an element.
3. Data Payloads: For nested data objects, you can specify their names and namespaces using @XmlSerialName to ensure they match the expected XML schema.

@Serializable
@XmlSerialName("Ge", "http://www.gxtlink.com/webservice/", "ns2")
data class GeResult<out T>(
    @XmlSerialName("code", "", "")
    @XmlElement(true)
    val code: Int,
    val data: T
)

@Serializable
@XmlSerialName("data", "", "")
data class GeResultData(
    @XmlElement(true)
    val project: String,
    @XmlElement(true)
    val unit: String
)

A DynamicTagReader is a custom XmlDelegatingReader used during deserialization to transform dynamic tag names (like Test_123) into a static, structured format that the serialization framework understands.

Key Responsibilities

• Tag Normalization: Overrides localName, namespaceURI, and prefix at the target depth to return the expected static name from the XmlDescriptor instead of the dynamic name found in the XML.
• Attribute Injection: Synthetically injects attributes (like an id attribute) into the stream. For example, it can intercept the dynamic part of the tag name (the 123 in Test_123) and present it as a standard attribute value.
• Depth Awareness: Uses a filterDepth calculation to ensure transformations only apply to the specific level of the XML hierarchy being handled, preventing accidental corruption of parent or child elements.

internal class DynamicTagReader(reader: XmlReader, descriptor: XmlDescriptor) : XmlDelegatingReader(reader) {
    // ... implementation details for normalizing localName, namespaceURI, and injecting attributes
    override val localName: String
        get() = when (filterDepth) {
            0 -> elementName.localPart
            else -> super.localName
        }
}