I have a class that is used to be serialized to Json without problems with kotlin 1.2 (0.6.2 with no customized serializers). after migrating to 1.3 (0.8,3), it stopped working, complaining about either some enum class or java singletonMap can't be serialized. is this expected? I don't see any mentioning about backward imcompatibility in the 1.3 doc.

Another one. I have a java class which consist mainly of primitive properties (lets assume only from primitive properties). Do I really have to write a serializer which contains something like

val json = JsonObject(mapOf(
            "apiId" to JsonPrimitive(obj.apiId),
            "organizationId" to JsonPrimitive(obj.organizationId),
//            .... endless ...
        ))

Am I the only one having problems with MyObject.serializer()? It stopped working after an update (not sure which, I'm checking now) and now I only have MyObject::class.serializer()

Is there a simple gradle kts dsl example I can't figure this out

What is the most efficient and correct way to check that some class can be serialized/deserilized using kotlinx.serialization Of course for simple cases you can check presence of annotations using reflectsions (also would be good to avoid, at least provide some conventional way). What about complicated ones (external serializers etc)? My use case that I would like to adopt kotlinx.serialization but we have a lot of existing data modesl and use Gson for Json mapping, so it would be hard to migrate everything at the same time I’m looking for some migration strategy, one of them to use Gson only as fallback during migration phase

Is there any advanced doc on writing custom KSerializer ?

Kotlin serialization support consists of three parts: a compiler plugin, which produces visitor/serializer code for objects, an IntelliJ plugin and a runtime library.

Are intellij plugin and compiler plugin open source? I can't find them on github

Is there any way for Jackson-style

As.PROPERTY

polymoprhic deserialization (e.g.,

{"type": "some.class.Name", "property": "value"}

instead of

["some.class.Name", {"property": "value"}]

) with kotlinx.serialization? I actually have some even more polymorphic gnarly (de)serailization requirements, which I could handle by some pretty ugly custom Jackson (de)serializers, but I would be interested a JVM-idependent solution. A key idea seems to be some kind of lookahead, during which Jackson can put tokens into a

TokenBuffer

while searching for the

"type"

attribute, and prefix the remaining token stream with the buffer contents upon calling the concrete deserializer. As the JSON schema I have to handle clearly wasn't designed with ease of parsing in mind, I have to rely a lot on lookahead. I am unsure how to achieve something similar with

KInput

and

KSerialClassDesc

.

What serialization version should be used for 1.3 release - 0.9.0?

so this is outdated ? https://github.com/Kotlin/kotlinx.serialization#gradlejvm

@jasoet so yes you do need that.. see the stuff i linked for the settings.gradle.kts configuration that allows you to just apply it in a

plugins

block

that kts is scary... is that how normal people are supposed to use it?

Sorry if this isn't the correct channel for this question. I attempted to upgrade to Kotlin 1.3. I had been using Kotlinx Serialization 0.6.2 and its associated plugins for Maven and Intellij. When I attempted to build, the compiler errors out on the @Serializable annotation with: java.lang.IllegalStateException: Backend Internal error: Exception during code generation Cause: org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl.initialize(Lorg/jetbrains/kotlin/types/KotlinType;Lorg/jetbrains/kotlin/descriptors/ReceiverParameterDescriptor;Ljava/util/List;Ljava/util/List;Lorg/jetbrains/kotlin/types/KotlinType;Lorg/jetbrains/kotlin/descriptors/Modality;Lorg/jetbrains/kotlin/descriptors/Visibility;)Lorg/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl; I removed the Kotlinx plugin from Maven pom, and rebuilt the compile succeeds but my unit test fail with the exception: kotlinx.serialization.SerializationException: Can't locate default serializer for class <myclass> I then tried by upgrading to Kotlinx Serializer 0.9.0, but the signature fo kotlinx.serialization.json.JSON.stringify and parse have change to require a Serializer as its first argument and the @ImplicitReflectionSerializer annotations for all clients - this change doesn't seem to be documented anywhere and for me has major implications. I have to ask all my clients to add @ImplicitReflectionSerializer before using my library methods. Is there a better way to handle this change. It seems like a "breaking" change that should have been called out and documented. Here is my code with the issue, wondering if Generics is contributing to the issue: inline fun <reified T: Any> parseToClass(jsonResponse: String): T { try { return JSON.nonstrict.parse<T>(jsonResponse) } catch(ex: Exception) { Logger.error("Failed to parse JSON to class ${T::class.simpleName}", ex) throw ex } }

Never mind, it's just that you can't use the IDE's run button in the gutter to run the tests. They must be done through gradle.

https://github.com/Kotlin/kotlinx.serialization#gradlejvm this sample refers to

kotlin-serialization

, was the plugin renamed ?

Hi, I am trying to maintain some backward compatibility to serialized JSON: for example

{
  "a": {
    "b": "c"
  }
}

to

@Serializable
class Wrapper(val a: Map<String, Any> = mapOf())

what's the easiest way? (if there a way I can specify default (e.g,

LinkedHashMap

) for Map and default (

String

) for "c"?

so with 0.9.0 i cannot longer just rely on implicit reflection and use

JSON.stringify(something)

for now i solved it like this

data class Something(
    val someProperty: String
) {
    @Serializer(forClass=Something::class)
    companion object
}

JSON.parse(Something, string)

is there a better way than adding companion objects to everything ?

<http://logger.info|logger.info>("loading configuration")

        val rootFolder = File(".").absoluteFile
        val configFolder = rootFolder.resolve("config")
        configFolder.mkdirs()

        val baseFile = configFolder.resolve("base.hocon")

        val parser = ConfigParser()

        val config = ConfigFactory.parseFile(baseFile)
        println(config)
        val baseConfig = parser.parse(config, BaseConfiguration.serializer())

        println(baseConfig)

BaseConfiguration is

@Serializable
data class BaseConfiguration (
    @Optional var ids: List<Int> = listOf(),
    @Optional var strings: List<String> = listOf()
)

@sandwwraith there seems to be no

stringify

for typesafe config, is that some limitation of the urrent codegeneration done by kotlinx or did nobody got around to implement that yet ?

Maybe a typo somewhere? Any differences from this pom? https://github.com/Kotlin/kotlinx.serialization/blob/master/example-jvm/pom.xml

hi all, i have a somewhat complex use case for serialization for messages being communicated around a distributed system. The messages come in like so:

{
	"sessionId": "...",
	"commandId": "...",
	"message": { ... }
}

So, at a lower layer of my code, I parse the

sessionId

and the

commandId

using

JsonTreeParser

, and using the same parser I extract

message

as a JsonObject. Later on, whoever needs to use the

message

JsonObject can deserialize to whatever they want using

mapper.readTree

. Now, say I need to serialize back to another format. Specifically:

{
	"success": true,
	"message": "...",
	"commandId": "...",
	"payload": { ... }
}

That

payload

field is any custom class which needs to be serializable and passed somehow, but I can't find a way to make it a JsonObject, or write any JsonObject for that matter. I also tried making a generic class with an field of the type of

payload

, but that didn't seem like the right direction. I guess what I'm asking is, how can I create a JsonObject from an instance of a class?

What is the status for

encodeDefaults

and JSON serializer? This case doesn't work for me:

@Serializable data class N(val s: String, val l: List<Int>? = null)
        assertEquals("""{"s":"s"}""", JSON(encodeDefaults = false).stringify(N.serializer(), N("s")))

I'm trying to get a long field to encode as a string instead of as a number in JSON (for values that overflow double):

@Serializer(forClass = Long::class)
object LongStrSerializer : KSerializer<Long> {
    override fun deserialize(input: Decoder): Long =
            input.decodeString().toLong()

    override fun serialize(output: Encoder, obj: Long) =
            output.encodeString(obj.toString())
}

@kotlinx.serialization.Serializable
data class PlayerSummary(
        @kotlinx.serialization.Serializable(with = LongStrSerializer::class)
        val id: Long,
        val displayName: String
)

However this still results in:

{
  "displayName": "Jessie James",
  "id": 1337000000
}

What am I doing wrong?

Is there way to deserialize

JsonElemet

as field of

@Serializable

class? Example:

@Serializable
data class Test(
    val a: Int,
    val b: JsonElement
)

val test = JSON.parse(Test.serializer(), """{"a":1,"b":{"test":"test2"}}""")
println(test.toString())

How to debug this:

kotlinx.serialization.json.JsonParsingException: Invalid JSON at 1221: Expected '[, kind: kotlinx.serialization.UnionKind$POLYMORPHIC@1e6d1014'

@sandwwraith is there any version for 1.3.20?

Is it possible to serialize a field that can be either boolean or Double? (No it's not my API, I wouldn't have designed it that way)

I did believe it should be faster, as the different fields are identified during compilation and no reflection should be needed in runtime. I may be wrong though. Could someone else shed some light here?

I’ve created a very basic library to add support for YAML to kotlinx.serialization: kaml It’s very limited at the moment (it only supports deserialisation) and is very, very rough (I’ve taken a bunch of shortcuts that will hurt performance, and there are a bunch of error messages that aren’t great), but I’d love any feedback, suggestions or contributions you might have 🙂 More details: https://github.com/charleskorn/kaml