How does one catch JsonDecodingException? seems like it is internal to kotlinx

Have a custom serializer:

import kotlinx.serialization.*
import kotlinx.serialization.json.Json

// Uncomment to disable encoding default values
// @Serializable
internal class Action(
    val id: String,
    val routing: String? = null,
)

@Serializer(forClass = Action::class)
object ActionSerializer : KSerializer<Action>

fun main(args: Array<String>) {
    val action = Action(
        id = "1",
    )
    println(Json.encodeToString(ActionSerializer, action))
}

This code produces:

{
  "id": "1",
  "routing": null
}

If you uncomment

@Serializable

annotation default values will be ignored. Is this behavior a bug or not?

Hey for

polymorphism

it currently uses the

type

attribute. Is there any way to change the name? In my case I need it to look at the

name

attribute (which is the same as

type

just different name)

has anyone made a https://json5.org/ version of serialization yet? that would be very nice to use for config file purposes

After ~4 months or so doing a considerable amount of JSON rpc development that is heavily polymorphic (uses serialization extensively), my conclusion is that there are two essential paradigms for dealing with serializing polymorphic things: format + modules, or Json + serialization strategies. The latter has dominated my work so far but I have a hunch I might be selling format + modules short. If you use a lot of polymorphism and KXS, which approach do you use/prefer. If you've seen this question dealt with in a paper, written by Roman, no doubt, 🙂, do send me a link. Much appreciated.

Hello all! I'm trying to serialize 

Any

 in a nested Map and I'm using the @contextual method defined in this post:

@Serializable
data class Media(
    val id: String? = null,
    val title: String? = null,
    val tracking: Map<String, Map<String, @Contextual Any>> = mapOf(),
)

val json = Json {
    ignoreUnknownKeys = true
    serializersModule = SerializersModule {
    contextual(String.serializer()) // could be an Int
    contextual(Int.serializer()) // could be a String
    contextual(Boolean.serializer()) // could be a Boolean
   }
}

val media = json.decodeFromString(Media.serializer(), MediaResponse.json) //MediaResponse.json is a string

I'm still getting this error

kotlinx.serialization.SerializationException: Serializer for class 'Any' is not found.
Mark the class as @Serializable or provide the serializer explicitly.

Am I missing something?

I am trying to use serialization with an

enum class

. I have read the appropriate documents (I think) and am using the appropriate annotations and strategies (I think), but I am still encountering a run-time issue immediately. I am also encountering a compile-time issue, I think, because the compiler doesn’t believe that there’s a

serializer

method on my

enum class

.

Hi, When changing serialization version from 1.0-M1-1.4.0-rc that was release with Kotlin 1.4.0 to 1.0.1 , Gradle says

Failed to resolve: org.jetbrains.kotlinx:kotlinx-serialization-runtime:1.0.1

Isn't this available on jcenter? or what should I do?

I want to write an encoder for a format that only supports lists with elements of a single type. What's a good way to ensure that's the case when encoding collections and their elements? Right now I'm thinking of having a check in

beginCollection

to require

descriptor.elementsCount == 1

, but I'm not sure if that guarantees homogeneity in all cases. (I'm pretty sure it'll work for the standard collection serializers, but besides that I'm not sure)

oh, don't mind me, I think I've typed something wrong... this seems to work:

"-Xopt-in=kotlinx.serialization.ExperimentalSerializationApi"

in build.gradle.kts

Hi, had a hard time finding information about

CommonEnumSerializer

/

EnumSerializer

. I try to use openapi-generator KMP export to generate data classes from json swagger and generated models uses unresolved

CommonEnumSerializer

, for example

@Serializable(with = Env.Serializer::class)
enum class Env(val value: kotlin.String){
    notDeployed("not_deployed"),
    inDeployment("in_deployment"),
    deployed("deployed");

    object Serializer : CommonEnumSerializer<Env>("Env", values(), values().map { it.value.toString() }.toTypedArray())
}

What is the current way for doing that ? Or how to find/use

CommonEnumSerializer

🤓

Give a TypeScript interface: `interface Foo { foo?: integer | string }`how might I represent this in Kotlin with KXS?

Hello, World! I need to serialize a map of string to "anything" (could be an object, could be an int, a string, etc.). What's a way to declare the custom

Serializer

for this? (in particular, what

SerialDescriptor

can I use?) Thanks!

Hi everyone, the webservices I'm using return an object wrapped in another object:

{

"d": {

"id": 3,

"name": "Tiago"

}

}

Is there any way to make it so that I don't have to make a wrapper class in every Serializable class? Something like @path, with XML Parser:

@Path("Body/GetAllVehicleBrandsResponse")
private List<InstallerVehicleBrand> allVehicleBrandsResult;

(Here I didn't need to make a Body class)

Hi everyone, simple question: I have a JsonObject:

val jsonObject = jsonElement.jsonObject

How do I add a new entry to the object? (something like this:)

jsonObject.addProperty(name, value)

(name and value are both Strings)

Need some help here to serialize a property in a class that is a list of an interface. Specifically at line 47 I need to add something like

@Serializable(with = ????) val list: List<Stuff>

. But what ???? is is eluding me.

Json is

StringFormat

so it has methods like

encodeToString/decodeFromString

but is somehow available direct serialization/deserialization to ByteArray? Comparing to jackson that has

writeValueAsBytes

(create string with

encodeToString

and than convert to com.google.protobuf.ByteString, my case for PubSub):

Benchmark          Mode  Cnt       Score       Error  Units
JsonTest.jackson  thrpt   25  459596.078 ± 31782.902  ops/s
JsonTest.kotlin   thrpt   25  301485.307 ± 19990.942  ops/s

https://kotlinlang.slack.com/archives/C7A1U5PTM/p1612889899095700

Json.encodeToByteArray

– why this not available? Any plans to implement direct encoding to

ByteArray

?

Any hint of how to register a serializer for ArrayList, since I get

kotlinx.serialization.SerializationException: Class 'ArrayList' is not registered for polymorphic serialization in the scope of 'Any'.

I suppose streaming support is still far away, so, if you do not want heavy memory usage, kotlinx.serialization is still not a valid option. Is the kotlinx.io repo even being worked on? simce I think the initial plans were to integrate it with that.

Can kotlin custom serializer be any help on decoding weird/invalid JSON? I could do this in Java with Gson using custom deserializer. The challenge is following (list of mixed objects - String, then Object) . I tried using official guide and wrote custom deserializer here too, however it produces error already in

decoder.decodeStructure(descriptor)

when deserializing to

List<T>

how does it pick what concrete type to use? ArrayList, LinkedList, etc...?

Hello. I am updating serialization to 1.1.0-RC, and using Kotlin 1.4.30-RC (latest available for Canary), but I get this error:

Could not find org.jetbrains.kotlin:kotlin-stdlib-common:1.4.30-270.
Required by:
    project :salonbiz-library > org.jetbrains.kotlinx:kotlinx-serialization-core:1.1.0-RC
    project :salonbiz-library > org.jetbrains.kotlinx:kotlinx-serialization-json:1.1.0-RC

Do I perhaps have to add an explicit dependency to stdlib, or something else going on?

Hi everyone, I'm consuming data from a JSON API. Some responses contain decimal numbers. Depending in the culture-info field sent to the server, they might use dots (e.g. 18.312) or commas (e.g. 18,312) Is there some way I can interpret these both as Float in my Serializer class (Float only accepts dot notation)? Maybe through some custom field desserialization or something...?

Colleagues, any idea why serializer stumbles upon this valid JSON?

coerceInputValues

is true. (offset 22 is begin of first null)

kotlinx.serialization.json.internal.JsonDecodingException: Unexpected JSON token at offset 22: Expected end of the array or comma
JSON input: {"rows":[["Connected",null,null,null,null,null,null,.....

Hello 👋 Any suggestions on how to write a custom

KSerializer

that behaves similar to the built-in ones for primitives? e.g. I can deserialize

Double

from Number (Int/Float) or String representation

var kotlinxDouble: Double = format.decodeFromString("""
    0
""".trimIndent())
println(kotlinxDouble)

kotlinxDouble = format.decodeFromString("""
    1.0
""".trimIndent())
println(kotlinxDouble)

kotlinxDouble = format.decodeFromString("""
    "2.0"
""".trimIndent())
println(kotlinxDouble)

tried

object BigDecimalStringSerializer : KSerializer<BigDecimal> {

    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("BigDecimal", PrimitiveKind.STRING)

    override fun serialize(encoder: Encoder, value: BigDecimal) {
        encoder.encodeString(value.toString())
    }

    override fun deserialize(decoder: Decoder): BigDecimal {
        val raw = decoder.decodeString() // <-- blows up when not a String representation, i.e. on 0 and 1.0 values from above
        return BigDecimal(raw)
    }
}

Is there something like

decoder.getRawValue

or something like that?

Hello 👋 Is there a way to deserialize JSON response to just a hashmap? I have to handle the response where a field is an arbitrary JSON, e.g.

@Serializable
data class GraphQLResponse<T>(
    val data: T? = null,
    val errors: List<GraphQLError>? = null,
    val extensions: Map<Any, Any>? = null // complains about missing serializer for Any
)

Hi everyone, Do you know if there is a way to add a default type for sealed class serialization or any discussion regarding this somewhere? Imagine that you have two Styles (default and dark):

@Serializable
sealed class Style {

   @SerialName("default")
   object Default : Style()

   @SerialName("dark")
   class Dark(...) : Style()
}

Now in order to future-proof the above in case new styles are introduced, we want to use the Default style in case a new type (“light” f.x.) is introduced. Is there some idiomatic way to do this - besides using a custom serializer?

Is there a way to still generate a "default" serializer for a class that's annotated with

@Serialize(with = CustomSerializer::class)

?

Also, would it be possible to identify types which have serializers (generated or custom)?