0.20.0 breaks when upgrading kotlin to 1.4-M2:

kotlinx.serialization.CompositeDecoder kotlinx.serialization.Decoder.beginStructure(kotlinx.serialization.SerialDescriptor)’
java.lang.NoSuchMethodError: 'kotlinx.serialization.CompositeDecoder kotlinx.serialization.Decoder.beginStructure(kotlinx.serialization.SerialDescriptor)

Hello, I am trying to serialize a data class containing a

java.time.Duration

, but it doesn't work (

java.time.Instant

works fine), do I need to write a custom serializer? How can I serialize a Duration?

i am trying to consume a protobuf API over json and it uses

oneof

extensively. i originally built my data objects as just normal data classes with nullable fields representing the various oneof field options, but I’d really like to represent this with a sealed class. I started writing a custom decoder but I can’t figure out how to essentially “peek” and see which field is present so I know which serializer to use. anybody done this successfully?

Is there anyway to override the default polymorphic serialization for sealed classes? I’d like to redefine how subclasses are disambiguated.

What is the suggested approach for declaring a type that is basically

Any

but constrained to

String | Boolean | Int | Array | Map

, and then make that type serializable? Because there are no true union types in Kotlin, what I tried to do is this:

@Serializable
sealed class Value<out T>(val value: T) {
    class STRING(value: String): Value<String>(value)
    class BOOLEAN(value: Boolean): Value<Boolean>(value)
    class NUMBER(value: Number): Value<Number>(value)
    class ARRAY<V>(value: List<V>): Value<List<V>>(value)
    class DICTIONARY(value: Map<String, Any?>): Value<Map<String, Any?>>(value)
    object NULL: Value<Nothing?>(null)
}

Then, I have a number of data classes/interfaces that need to use this type, for example:

interface StoredValue {
    val type: String
    val value: JsonElement // This would become of type Value
}

@Serializable
data class NetworkRequest(
    val type: String,
    val data: JsonElement // This would become of type Value
)

But if I try to use

Value

in place of

JsonElement

, then I need to attach the generic type parameter to those classes/interfaces, and then I'm not sure how to deal with serialization on them.

is there anything like a alias for SerialModule ? or any other way to move / refactor sealed classes and have it parse old json that has values for

type

?

I want to serialize

SomeType

to a

String

and I’m using a custom

KSerializer<SomeType>

. I tried:

Json.stringify(SomeTypeSerializer, SomeType("some"))

But in the output I get

""some""

. Is there a way to get

"some"

(without extra quotes)?

does Kotlin Serialization support delegated properties or will i need to implement a custom serializer for that?

@Serializable
class Test {

    var firstName: String by Delegates.observable(
        initialValue = "Someone",
        onChange = { _, _, _ ->
            println("firstName changed")
        }
    )

}

val json = Json(JsonConfiguration.Stable)
    val test = Test()
    test.firstName = "Person"
    val jstring = json.toJson(Test.serializer(), test)
    println(jstring.toString())

ouputs:

{}

Is there a way to force a double to serialize to an int when it is a whole number? Failing that, is there a way to supply a custom serializer for only one class in a sealed class?

This message was deleted.

I'm trying to use kotlinx but I'm getting this error:

I'm trying to deserialize 2 JsonObjects but I appear to be having issues, any help is appreciated:

is there no

org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:0.20.0-1.4-M2

package?

What's the status on null values in protobuf right now? If I get it correctly protobuf 3 is capable of null values?

anybody else seen

class file for kotlinx.serialization.KSerializer not found

kapt errors before?

Say I have json that looks like this 

{
  "versions": {
      "android": {
          "recommended": "2020.06.01",
          "minimum": "2020.05.22"
      },

      "ios": {
          "recommended": "2020.06.01",
          "minimum": "2020.05.22"
      }
  }
}

And I want my model to look like this:

@Serializable
data class AppVersions(val recommended: String, val minimum: String)

Does anyone know how to use the Serializer to ignore a layer and look for

versions/android

? Is it as simple as assigning the Serial Name like that?

In general protubf seems really buggy. I.e. this code:

ProtoBuf.dump(Int.serializer().set, setOf())

Also just throws an exception:

Exception in thread "main" java.util.NoSuchElementException: List is empty.
	at kotlin.collections.CollectionsKt___CollectionsKt.last(_Collections.kt:372)
	at kotlinx.serialization.internal.TaggedEncoder.getCurrentTag(Tagged.kt:129)
	at kotlinx.serialization.protobuf.ProtoBuf$ProtobufWriter.beginStructure(ProtoBuf.kt:112)
	at kotlinx.serialization.Encoder$DefaultImpls.beginCollection(Encoding.kt:244)
	at kotlinx.serialization.internal.TaggedEncoder.beginCollection(Tagged.kt:22)
	at kotlinx.serialization.internal.ListLikeSerializer.serialize(CollectionSerializers.kt:73)
	at kotlinx.serialization.protobuf.ProtoBuf$ProtobufWriter.encodeSerializableValue(ProtoBuf.kt:148)
	at kotlinx.serialization.EncodingKt.encode(Encoding.kt:402)
	at kotlinx.serialization.protobuf.ProtoBuf.dump(ProtoBuf.kt:541)
	at kotlinx.serialization.protobuf.ProtoBuf$Default.dump(ProtoBuf.kt)

can kotlinx.serialization be convinced to allow for some non-exact class matches when polymorphic? I'd like to use it on various data structures containing

CharSequence

. regardless of the exact type, I want to handle them all the same way - serialize their

.toString()

, and a subset of their spans if

Spannable

(Android interface), ignoring everything else. but it seems like polymorphic(CharSequence::class) is forcing me to write a separate serializer for every possible concrete class

does kotlinx serialization in jvm rely on reflection?

How do I make this polymorphically serializable?

@Serializable
sealed class Result<T> {
    @Serializable
    class Success<T>(val data: T) : Result<T>()

    @Serializable
    class Failure<T>(val msg: String) : Result<T>()
}

So that If I have a class

@Serializable
data class Person(val name:String)

I can call

Json.stringify(Result.Serializer(Person.serializer()),Result.Success(Person("Andy)))

I have little knowledge in Polymorphic Serialization

Hey all. So I got a cryptic

UnsupportedOperationException: IrValueParamterImple...

error and spent an hour trying to find out why. Had to move some private var initializations into the init{} function to get things working. Is the dev team is interested in perhaps making this error a bit less cryptic? If so, I could open a Github issue.

I'm having issues to resolve the serialization runtime: https://pastebin.com/raw/uEj4DrHx

does

@serializable

make the class implement an interface? i would like to have a generic method accept only serializable classes, something like

<T : Serializable>

trying to use the new 1.4-M3 but getting this error

Plugin [id: 'org.jetbrains.kotlin.plugin.serialization', version: '1.4-M3'] was not found in any of the following sources:

…i added

maven ("<https://dl.bintray.com/kotlin/kotlin-eap>")

to my

repositories

but still no luck, anybody know how to fix?

is JsonElement appropriate for comparing arbitrary JSON strings for equality? It seems to work fine but I haven't done any kind of exhaustive testing, wondering if anyone else has used it for that

Hi guys, would it be possible to bring the

classDiscriminator

from context level to base class level? For example

@Polymorphic(discriminator="command")

or as part of the SerialModule:

polymorphic("command", Message::class) { ... }

or similar? It would add a great flexibility and it doesn't seem very difficult to add to the current design.

Can anyone clarify whether `ByteArray`s are currently serialized efficiently to CBOR format?

Hi here, I have a question on custom deserializers. If I want to use the approach 2 from here, https://medium.com/transferwise-engineering/how-to-master-polymorphism-and-custom-serializers-in-kotlinx-serialization-7190da0f42aa to define a custom serializer on a data object, is there a way to still use the default deserializer for the class within the custom one? For the use case, we want to be able to use the default deserializer exactly as is and AFTER deserializing then set the json blob as a field on the class. (We need to do this to support phasing out existing deserializers while we're replacing the old classes with our new classes from a library)

Hi folks, I'm creating a new type of encoding here for my project and I want to be able to get Annotations in Generic Types of a List or Map in the SerialDescriptor, is possible? I know that this is possible

val messages: List<@Serializable(with = ChangeColor::class) String>

and I'm trying a lot here and I could not find a way. I want to be able to do something like this:

val messages: List<@ChangeColor String>