how do I use a delegate serializer and deserialize...

# serialization

[Bernhard]

how do I use a delegate serializer and deserialize the value without consuming it first? my understanding based on the method signatures is that calling decoder.decodeX() consumes the token, correct? I'm trying to do this:

object LanguageIsoSerializer : KSerializer<LanguageIso?> {
    private val delegate = serializer<LanguageIso>().nullable
    private val parsingDelegate = serializer<String>().nullable

    override val descriptor: SerialDescriptor
        get() = SerialDescriptor("at.fyayc.emporixapi.i18n.LanguageIso", delegate.descriptor)

    override fun serialize(
        encoder: Encoder,
        value: LanguageIso?
    ) {
        delegate.serialize(encoder, value)
    }

    override fun deserialize(decoder: Decoder): LanguageIso? {
        val string = parsingDelegate.deserialize(decoder)
        return if (string.isNullOrBlank()) {
            null
        } else {
            delegate.deserialize(decoder)
        }
    }
}

Technically I could use the parsed string and just iterate over enum entries, but that would ignore any annotation on the enum itself like @SerialName

[ephemient]

if it's JSON,

(decoder as JsonDecoder).json.decodeFromElement(delegate, JsonPrimitive(string))

there isn't a general way to do this for other formats

[Bernhard]

so basically wrap it in an element again, then pass it to the second deserializer

[ephemient]

actually what I'd do is not use parsingDelegate and instead use (decoder as JsonDecoder).decodeJsonElement() but it works out the same

[phldavies]

Another option may be to use JsonTransforming and transform blank to null

[ephemient]

oh and as it's an enum, another option is to use its descriptor which has all the serial names of the entries

[Bernhard]

@phldavies thanks, will take a look at that as well, trying to grasp both solutions

[Bernhard]

override fun deserialize(decoder: Decoder): LanguageIso? {
        if (decoder !is JsonDecoder) throw SerializationException("Can only deserialize JSON")
        val string = parsingDelegate.deserialize(decoder)
        return if (string.isNullOrBlank()) {
            null
        } else {
            // since string was consumed from parser stream, if we just passed the decoder, it'd be gone
            // so instead, wrap it in a JSON element again
            decoder.json.decodeFromString<LanguageIso>(string)
        }
    }

[Bernhard]

like this?

[ephemient]

no their suggestion is https://kotlinlang.org/api/kotlinx.serialization/kotlinx-serialization-json/kotlinx.serialization.json/-json-transforming-serializer/

[Bernhard]

right I meant your solution

[ephemient]

yes

[ephemient]

their suggestion is

object LanguageIsoSerializer : JsonTransformingSerializer<LanguageIso?>(LanguageIso.serializer().nullable) {
    override fun transformDeserialize(element: JsonElement): JsonElement =
    if (<http://element.primitive.content.is|element.primitive.content.is>Empty()) JsonNull else element 
}

which may be better suited for your specific case

[Bernhard]

thank you, was just trying to work it out but you were faster 🙂

[Bernhard]

object LanguageIsoSerializer2 : JsonTransformingSerializer<LanguageIso?>(serializer<LanguageIso>().nullable) {
    override fun transformDeserialize(element: JsonElement): JsonElement =
        if (element is JsonPrimitive && element.content.isBlank()) {
            JsonNull
        } else {
            element
        }
}

[Bernhard]

hah, the super class basically does exactly the same

[Bernhard]

final override fun deserialize(decoder: Decoder): T {
        val input = decoder.asJsonDecoder()
        val element = input.decodeJsonElement()
        return input.json.decodeFromJsonElement(tSerializer, transformDeserialize(element))
    }