Is there a more elegant way to solve

ImplicitReflectionSerializer

? I want to create generic method to send data classes through Websocket. At the moment I have this:

suspend fun <T> send(item: T, serializer: KSerializer<T>) {
    // TODO
}

but it is a bit awkward to always pass the serializer. Since I'm always sending data classes which do not support extension, runtime type is not important to me, I would be fine with just detecting the compile-time type.

Is partial deserialisation supported? I have a Json object where I know some fields will be there and others may not but I don't know what they are called at compile time. Can the plugin shove all the unknown keys into a

JsonObject

member?

I have

data class Request(val mode: String = "default", val extra: String? = null)

, this produces

{ "mode": "default", "extra": null }

. Can I get it to omit the field entirely instead of setting it to

null

?

Is having a

classDiscriminator

per parent class planned?

I've updated documentation with an article about polymorphic serialization, hope it will answer some of your questions: https://github.com/Kotlin/kotlinx.serialization/blob/master/docs/polymorphism.md

Seems that idea of having different `classDiscriminator`s per one response is really popular. We'll take a look on how we can implement this.

I'm trying to serialize a tree of expressions that must match a format that will be sent to an api. The expressions are a set of sealed classes that may or may not contain other expression classes. For instance the root is always an expression class that contains a list of other expression object as one of it's properties. Each node in the tree has it's own discriminator property called type. Right now I don't need to deserialize this json but I may need to in the future. The important part is that my output match the api. An example looks like:

{
  "type": "V",
  "expressions": [
    {
      "type": "M",
      "expr": "5+6"
    }
  ],
  "resultType": "success"
}

I started to go down the route of using the polymorphic serializer but I didn't know how to customize the

type

output. Should I write my own custom serializer for this type? If so is there a good example of how to do this?

Learning kotlin/react/redux. Redux doesn't like a "preloadedState" to be anything other than a plain js object. Sending back an initialized data class makes it complain about expecting an object, not and "Object". This is the best I could figure, is there a better way that I'm missing?

package index.store.state

import index.model.User
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonConfiguration

@Serializable
data class State(val users: Array<User> = emptyArray())

fun state(): State {

    val json = Json(JsonConfiguration.Stable)

    return JSON.parse(
        json.stringify(
            State.serializer(),
            State()
        )
    )
}

It feels cleanish, but it seems like there might/should(?) be a native function I can't find that converts a data class to a kotlin.js.Json object.

How does one create a

Json

without treading experimental?

it does not offer CSV as a built-in serialization target but the plugin is agnostic to formats meaning you are able to support CSV yourself

Has anyone seen this error before?

Caused by: kotlinx.serialization.SerializationException: Can't locate argument-less serializer for class com.kevincianfarini.saddle.Artist$Impl (Kotlin reflection is not available). For generic classes, such as lists, please provide serializer explicitly.

I've done some searching but none of the solutions I've found have worked.

While making a custom encoder/decoder, it is possible to support additional data formats so that users don't need to do

@Serializable(with = ...::class)

whenever they use the data format? For example, support UUID:

class MyEncoder : NamedValueEncoder {
     fun encodeInt() { ... }
      ...
     fun encodeUUID() { ... }
}
class MyDecoder : NamedValueDecoder {
      fun decodeInt() { ... }
       ...
      fun decodeUUID() { ... }

And then users can do:

@Serializable
data class OtherFormats(val uuid: UUID)

Instead of:

@Serializable
data class OtherFormats(@Serializable(with = UuidSerializer::class) val uuid: UUID)

(where

UuidSerializer

is the name of a class annotated with

@Serializer(forClass=UUID::class)

)

Turns out it's this combination of annotations that makes it choke:

@ExperimentalUnsignedTypes
@FlowPreview
@ObsoleteCoroutinesApi
@ExperimentalCoroutinesApi

Hey guys, I have a Json which can have a certain key that varies in name but I cant seem to find out how to do this.. any ideas? I really just need the value inside it..

with kotlin 1.3.41 and serialization 0.11.1 gradle says that it can't find kotlinx . any idea whats going wrong?

I'm consuming an api that uses an empty string for a null but sends an object when the key is not null like so:

"mods":{"mod1":""}
"mods":{"mod1":{"comp":">=","point":3}}

Is there a way to construct a class or annotate the property to deal with this?

Hey everyone. I am trying to define an external serializer for a data class (

Data

) which is defined in another gradle module (subproject) and the result is the following exception:

Caused by: java.lang.IllegalStateException: Class Data have constructor parameters which are not properties and therefore it is not serializable automatically
        at org.jetbrains.kotlinx.serialization.compiler.backend.common.SerializerCodegen.checkSerializability(SerializerCodegen.kt:38)
        at org.jetbrains.kotlinx.serialization.compiler.backend.common.SerializerCodegen.generateSerializableClassPropertyIfNeeded(SerializerCodegen.kt:106)
        at org.jetbrains.kotlinx.serialization.compiler.backend.common.SerializerCodegen.generate(SerializerCodegen.kt:44)
        at org.jetbrains.kotlinx.serialization.compiler.backend.jvm.SerializerCodegenImpl$Companion.generateSerializerExtensions(SerializerCodegenImpl.kt:49)
        at org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationCodegenExtension.generateClassSyntheticParts(SerializationCodegenExtension.kt:30)
        at org.jetbrains.kotlin.codegen.ImplementationBodyCodegen.generateSyntheticPartsAfterBody(ImplementationBodyCodegen.java:438)
        at org.jetbrains.kotlin.codegen.MemberCodegen.generate(MemberCodegen.java:132)
        at org.jetbrains.kotlin.codegen.MemberCodegen.genClassOrObject(MemberCodegen.java:302)
        at org.jetbrains.kotlin.codegen.MemberCodegen.genClassOrObject(MemberCodegen.java:286)
        at org.jetbrains.kotlin.codegen.PackageCodegenImpl.generateClassesAndObjectsInFile(PackageCodegenImpl.java:118)
        at org.jetbrains.kotlin.codegen.PackageCodegenImpl.generateFile(PackageCodegenImpl.java:137)
        at org.jetbrains.kotlin.codegen.PackageCodegenImpl.generate(PackageCodegenImpl.java:68)
        ... 44 more

Everything works if the data class is defined in the same gradle module as the serializer though. Has anyone here experienced this as well?

This message was deleted.

Is there an

ArraySerializer

? For primitives like

ByteArray

How can a custom format support polymorphic serialization by accepting a

SerialModule

? I can't find where

Json

and other formats handle the

SerialModule

.

Good Morning guys I'm getting JsonParsingException: Invalid JSON at 55: Expected string or non-null literal while parsing a json that has a field called data which can be null but it could also be a json-object with varying keys. So my idea was to parse it to a String but it seems that that is what's causing the issue. Any ideas on how to accomplish this?

I'm looking for a way to serialize a specific class using a specific method in my

NamedValueEncoder

/

NamedValueDecoder

.

class MyClass {
   /**  **/
}

Doing that in a

ElementValueEncoder

is simple enough :

class MyEncoder : ElementValueEncoder(){
    fun encodeMyClass(obj : MyClass){
         /** **/
     } 
}
// And then in serializer...
@Serializer(forClass = MyClass)
object MyClassSerializer : KSerializer<MyClass> {
      override fun serialize(encoder: Encoder, obj: MyClass) {
        if(encoder is MyEncoder){
            encoder.encodeMyClass(obj)
        }
        else error("not supported")
    }  
}

However, I cannot see how I can do the same thing in a

NamedValueEncoder

, as it requires a tag, which I don't know how to generate.

class MyTaggedEncoder : NamedValueEncoder(){
    fun encodeTaggedMyClass(tag: String, obj : MyClass){
         /** **/
     } 
}
// And then in serializer...
@Serializer(forClass = MyClass)
object MyClassSerializer : KSerializer<MyClass> {
      override fun serialize(encoder: Encoder, obj: MyClass) {
        if(encoder is MyTaggedEncoder){
            encoder.TaggedMyClass( ??????,      obj)
        }
        else error("not supported")
    }  
}

I don't have access to the methods that generate the tag, to be used in the area marked as "?????", as they are private in

NamedValueEncoder

. There are also no methods that allow

Any

class to be encoded in

NamedValueEncoder

(of which I don't need to provide a tag myself to) . So how can I encode / decode a tagged

MyClass

in this situtation?

I have two types, one a subclass of the other, and I’m trying to make it work with the serialization library:

@Serializable
open class Foo(open val foo: String)

@Serializable
data class Bar(override val foo: String, val bar: String) : Foo(foo)

The compiler is pointing on

Bar

that I have

foo

declared twice (

has duplicate serial name of property foo, either in it or its parents

). I could not find this scenario on the polymorphism doc. Does anyone know how to get around this?

I've got a

MutableMap<Name, @Polymorphic T>

field, where

Name

is an inline class. I have custom serializer for name. Is it possible to somehow implement a serializer for the map inheriting polymorphic behavior?

How can I support default values in my addon-format? How can I 'tell' the deserializer "here, this value doesn't exist, use the default value instead"

Maybe a dumb question. I've got a

data class MyClass(val foo: String)

that I can conveniently retrive from dynamic JS by using

DynamicObjectParser().parse(js("""{ foo: "bar" }"""), MyClass.serializer())

. Is there a way that I can do the opposite, going from an instance of

MyClass

to a dynamic type JS blob

{ foo: "bar" }

? The goal is to be able to call into the Kotlin/JS artifact from real-JS and be able to predictably interact with the output without having extra bits of data on it. I can get to a

Map<String, Any?>

using

Mapper.mapNullable(MyClass.serializer(), instance)

, but I'm not sure if there's a step that I'm missing after that...

Alternatively is this something that I could write some sort of general-purpose

AbstractSerialFormat

implementation for?