Suppose I have a JSON string like this:

[36, {"color": "orange", "sizes": [23, 42, 7]}]

(so a mixed JSON array) where the first entry of the array is always an

Int

that represents a type of message and the second is an arbitrary map payload. I, as a library, need to parse the type field to do some things, but I don't care about the payload and would like to deserialize into a type that is provided by my users. E.g.

fun <UserType> parseMessage(json: String): UserType

Can this be done via kotlinx serialization?

@Serializable
data class UserProfile(val id:String)

fun test() {
  val jsonElement = Json.nonstrict.toJson<UserProfile?>(NullableSerializer(UserProfile.serializer()), null)
  println("jsonElement: $jsonElement")
}

Above code throws following error in kotlin 1.3.31 x serialization 1.1.0.

Caused by: kotlinx.serialization.SerializationException: No tag in stack for requested element
        at kotlinx.serialization.TaggedEncoder.popTag(Tagged.kt:160)
        at kotlinx.serialization.TaggedEncoder.encodeNull(Tagged.kt:92)
        at kotlinx.serialization.internal.NullableSerializer.serialize(NullableSerializer.kt:39)
        at kotlinx.serialization.json.internal.AbstractJsonTreeOutput.encodeSerializableValue(TreeJsonOutput.kt:174)
        at kotlinx.serialization.CoreKt.encode(Core.kt:73)
        at kotlinx.serialization.json.internal.TreeJsonOutputKt.writeJson(TreeJsonOutput.kt:29)
        at kotlinx.serialization.json.Json.toJson(Json.kt:129)

has anyone experienced this issue?

How does one use the polymorphic stuff for sealed class heirarchies? Can I get away with only annotating my sealed BaseClass with

@Polymorphic

?

is there a way to get the code of the generated de/serrializers?

does anybody know what the

SerialDescriptor

generated for a

@Serializable

class depends on?

Good day. I am working with an API that varies how dates are encoded. So I would like to do something like this:

@DateSerializer(format="MM-dd-YYYY")
var date1: Date

Is this possible with Kotlin Serialization (multiplatform)? Any examples anybody might be able to throw my way? Thank you!

Will the serialization plugin and runtime be published to the Gradle plugin portal and jcenter respectively once they exit experimental status?

What is best way to integrate kotlinx serialization+ktor client in a MPP? The only resource I could find is : https://ktor.io/clients/http-client/features/json-feature.html which refers to using a JVM dependency

Is it possible to inject a serializer? For example I have a data class in my gradle module

x

. It has a

UUID

and the

KSerializer<UUID>

lives in gradle module

y

. My module

x

doesn't know anything about my module

y

. Now I would like to inject that UUIDSerializer instance. Is that possible?

are enums still broken? marking one as

@Serializable

seems to break everything

Don't enums have a

.serializer()

function by default?

Hello, guys. I am currently making a simple tornadofx GUI to generate a XML configuration. I believer that in order to do so, the simplest way is to make my model classes seializable and use @pdvrieze's xmlutil and make my model classes seializable. In order to do so, I need to create custom serializators for javafx Properties. Like this:

@Serializer(forClass = StringProperty::class)
object StringPropertySerializer : KSerializer<StringProperty> {

    override val descriptor: SerialDescriptor = StringDescriptor

    override fun serialize(encoder: Encoder, obj: StringProperty) {
        encoder.encodeString(obj.value)
    }

    override fun deserialize(decoder: Decoder): StringProperty {
        return SimpleStringProperty(decoder.decodeString())
    }
}

I have two questions: 1. The property is nullable, how can I create a descriptor for nullable value. In @pdvrieze's code there is a delegate wrapper that copies descriptor functionality and switches the

nullable

flag. Is i the best way to do so. Do I even need the flag 2. Serialized xml seems to have class names for tag names instead of names of the peoperties. Is it something in serializaition, or a feature of

xmlutil

? 3. How can I tell enums to be serializaed into their names. Do I need custom serialized for that?

Can't a

KSerializer

do some look-ahead for the next token type when reading something? E.g. • if next token is string then decode as A • if next token is object then decode as B

-- And

kotlinx-serialization-runtime-native

0.11.0

isn't compatible with Kotlin 1.3.40-eap 😕

w: skipping /Users/marc/.gradle/caches/modules-2/files-2.1/org.jetbrains.kotlinx/kotlinx-serialization-runtime-native_debug_ios_x64/0.11.0/c80bda43e7d80430654f2ef709df51a073ed0f0e/kotlinx-serialization-runtime-native.klib. The abi versions don't match. Expected '[9]', found '8'
w: The compiler versions don't match either. Expected '[1.3]', found '1.2-release-9411'

Functions are basically non-serializable. You should use SAM classes or method references for that.

The kdoc of

Json.parse

states:

/**
     * Deserializes given json [string] into a corresponding object of type [T] using provided [deserializer].
     * @throws [JsonException] subclass in case of serialization error.
     */

However upon missing field it throws a

kotlinx.serialization.MissingFieldException

. Is this a known issue?

Sealed classes now do not have any special support, so you should use the same approach as if you were using regular polymorphic serialization (

@Polymorphic

annotation, SerializersModule, etc). We have plans to improve it in future.

Hello, I've just updated serialization library from 0.10.0 to 0.11.0 and now getting error: Unresolved reference: registerSerializer and Classifier 'PolymorphicSerializer' does not have a companion object, and thus must be initialized here

// * We need to register serializers for this RequestForChangeEvent to allow proper serialization for this type
    companion object {
        init {
            registerSerializer(RequestForChangeEvent::class.java.name, RequestForChangeEvent.serializer(PolymorphicSerializer))
            registerSerializer(ChangeRejectedEvent::class.java.name, ChangeRejectedEvent.serializer(PolymorphicSerializer))
            registerSerializer(ChangeAcceptedEvent::class.java.name, ChangeAcceptedEvent.serializer(PolymorphicSerializer))
        }
    }

how can I fix this?

Got compiler error when tried to compile:

@Serializable
interface EventData

error:

e: java.lang.IllegalStateException: Backend Internal error: Exception during code generation
Cause: Back-end (JVM) Internal error: @Serializable annotation on class EventData would be ignored because it is impossible to serialize it automatically. Provide serializer manually via e.g. companion object

This interface will be used as a marker interface and it will be used on data class X(...) : EventData

what's the

@SerialId

used for protobuf good for? are there any hints about how it should be used?

well.

null

is not supported with protobuf. that is a HUGE drawback

Why do I get

ISE: Class Duration have constructor parameters which are not properties and therefore it is not serializable automatically

When I specify

@Serializable(with = DurationSerializer::class)

and a matching

@Serializer(forClass = Duration::class)

? There shouldn't be automatic serialization. EDIT: oh wow, it happens when I "half-specify" a serializer. I had

deserialize

and

serialize

but not

descriptor

. Kinda unexpected that if you create a custom serializer it generates a descriptor automatically based on the constructor which may be a total mismatch with what my serializer actually does 🤔 Is that intentional?

Hi. Could you please advice how to fix

[Exception] class kotlin.String is not registered for polymorphic serialization in the scope of class kotlin.CharSequence class kotlinx.serialization.SerializationException

error?

@charleskorn Any idea how I can solve that: https://github.com/charleskorn/kaml/issues/1

What's the best way to report doc issues? I found some links to files that no longer exist and docs that don't seem to be valid anymore.

Hi, is it possible to configure the serializer to use simple class name instead of qualified class name for polymorphic serialization type field or do I have to write a custom serializer to achieve this?

Does polymorphic serializer support sub classes with generic type parameters?

@Serializable
sealed class Foo<T : Any> {
    @Serializable
    data class Bar<T : Any>(val o: T) : Foo<T>()

    @Serializable
    data class Baz(val o: String) : Foo<String>()
}

It's not possible to do something like

PolymorphicSerializer(Foo::class, UnitSerializer)

.

Why do example serializer implementations use

lateinit

for required properties? That will just throw an

UninitializedPropertyAccessException

at runtime if the property is missing during deserialization instead of the expected

SerializationException

. Due to the examples I've assumed that such a case can never happen because the descriptor states that these properties are mandatory and it would be checked internally. Doesn't seem to be the case though 😞