Is there a timeline for when creating custom

Decoder

implementations will no longer be

@ExperimentalSerializationApi

?

I’m reading official documentation on GitHub, and it looks like I need to add

SerialName

to all implementations to serialise the sealed interface. However, when I try to test it, I see that serialiset is not found for the discriminator. Does it mean I have to define all subclasses when defining the serializable module?

Hi, I feel like it should be possible to serialize a subclass of

com.google.protobuf.GeneratedMessageV3

automatically. Has somebody written a Contextual serializer that does that?

Hello, I'm just starting out on learning how to use KotlinX (and serdes in general) and I am running in to an issue I can't seem to understand how to solve. I have a

@Serializable class A

and I have a helper class for companions to automatically grab a file to deserialize something in to an

A

and put it in

A(.Companion).INSTANCE

. However, using

.INSTANCE

gets a bit annoying to use and looks kind of gross, so I am trying to convert

A

in to a

@Serializable sealed interface A

, so that

A.Companion

can be an

A

and I can simply reference

A

rather than

A(.Companion).INSTANCE

. I can't seem to understand enough to get this working with a

sealed interface

, I keep running in to polymorphism errors or NPEs if I try to delegate similar to how I do in

Loader

, so I am here for help. Here's a minimum example.

abstract class Loader<T>(val type: StringFormat, val filePath: String, val serializer: () -> KSerializer<T>, ) {
    val INSTANCE by lazy {
        type.decodeFromString(serializer(), File(filePath).readText())
    }
}

current

@Serializable
class A(val someProperty: Int) {
    companion object: Loader<A>(
        type = Json.Default, filePath = "./config/A-config.json", serializer = { A.serializer() }
    )
}

fun main() {
    A.INSTANCE.someProperty
}

goal

@Serializable
sealed interface A {
    val someProperty: Int
    companion object: Loader<A>(
        type = Json.Default, filePath = "./config/A-config.json", serializer = { A.serializer() }
    )
}

fun main() {
    A.someProperty
}

Where can i find the documentation/examples for Okio’s BufferedSource and BufferedSink with Kotlinx serialization ?

I cant get the example of external serializers to compile. It fails with :

Type mismatch: inferred type is ProjectSerializer but S
erializationStrategy<TypeVariable(T)> was expected

. What could I be doing wrong ?

import kotlinx.serialization.*
import kotlinx.serialization.json.*
import kotlinx.serialization.encoding.*
import kotlinx.serialization.descriptors.*

// NOT @Serializable
class Project(val name: String, val language: String)

@Serializer(forClass = Project::class)
object ProjectSerializer

fun main() {
    val data = Project("kotlinx.serialization", "Kotlin")
    println(Json.encodeToString(ProjectSerializer, data))
}

Hi all, trying to use

kotlinx-serialization-json-okio

like this in

commonMain

class ValueStore<T: Any>(
  val path: Path,
  val serializer: Json = Json,
  ..
) {
  suspend inline fun <reified V: T> set(value: V?) = lock.withLock {
    stateFlow.emit(value)
    serializer.encodeToBufferedSink(value, FILE_SYSTEM.sink(path).buffer())
  }
}

And have a

commonTest

written up like

private val store: ValueStore<Pet> = ValueStore(path = "test.json".toPath())

@Test
fun testWriteValue() = runTest {
  val mylo = Pet(name = "Mylo", age = 1, type = Cat)
  store.set(mylo)
  val actual: Pet? = store.get<Pet>()
  val expect: Pet = mylo
  assertSame(expect, actual)
}

This test is failing 🤔 Although, I can see the

test.json

file being created, but it is empty. Am I using this correctly? Full source here

Hi, is there a way to serialize an enum as the ordinal without adding SerialName for each key ?

Is it just me or is Json.decodeFromBufferedSource much slower than Json.decodeFromStream or Json.decodeFromString?

I want to utilize combined open and closed polymorphism, I have this class tree:

// in library
@Serializable
interface Base

// in user code
sealed interface All : Base {
   @Serializable
   object A : All

   @Serializable
   data class B(...) : All
}

Ideally, I'd like to register as a subclass only the All type and not every children (A, B, ...). Do I miss something or it is not possible?

Hi, I'm trying to deserielize content using ktor and kotlinx.serialization, and I'm getting a very weird

Illegal Input

when I get a response that is an empty array, so just

[]

, that should totally not create that error right ?

Hi all. I'm getting

kotlinx.serialization.json.internal.JsonEncodingException: Value of type 'kotlinx.serialization.Polymorphic<IdType>' can't be used in JSON as a key in the map. It should have either primitive or enum kind, but its kind is 'OPEN'.

where

interface IdType : Parcelable {
  val name: String
}

enum class PersonIdType : IdType {
  GIVEN_NAME, MIDDLE_NAMES, FAMILY_NAME
}

enum class VehicleIdType : IdType {
  PLATE_NUMBER, VIN, ENGINE_NUMBER,
}

is this a known limitation? 🤔

I'm curious, is there a rationale for having only read-only JsonElement classes, and not mutable versions? Asking because of this issue on my own kxa format implementation requesting mutable elements: here

Is there anywhere that details the specs for serializer structures? stuff like "polymorphic serializer's element 0 is expected to be the type name, and element 1 is the value. elements of value's descriptor are sealed subclasses, if any"

also, can MetaSerializable annotations be InheritableSerialInfo?

Could the following error message be linked to kotlinx.serialization? The

NoSuchMethodError

occurs when I try to use the

copy

function on a

@Serializable

data class

that has one enum, one

ULong

, and one

Long

.

java.lang.NoSuchMethodError: No virtual method copy-2TYgG_w(blablabla)_*blablabla*_

Hello, I am looking for XML serial format and got several recommendations about https://github.com/pdvrieze/xmlutil . Do anybody knows, does this library use/support stream parsing of xml's or not?

Hi, someone told me to ask here about serialization; I have several dozen formats of packets to send over USB, and I'm unsure how to define the classes to easily (de-)serialize them to/from a ByteArray/UByteArray send them over libusb from Kotlin/Native. How would I approach this?

Hi Is there any way to map dynamic keys? I have this piece of json, in which keys varies, i used to make use of groovy to parse those keys bug now we are moving to ktor.

flights_information": {
                "OD_CUNMIA_01_20221111": {
                    "CPA_1": {
                        "FL00GH8001": {
                            "arrival_information": {
                                "airport_reference_id": "MIA_0",
                                "change_day_indicator": "0",
                                "date": "2022-11-11",
                                "date_of_week_name": "Friday",
                                "time": "17:30:00"
                            },

When all compiler APIs become stable (FIR and so on), Kotlin Gradle Serialization plugin would be outside the Kotlin repo and having its own version? Serialization libraries are under kotlinx repo with its own version, I would expect that in the future for the plugin too

I have a question in regards to behavior differences when deserializing either raw

String

and

JsonObject

for target type classes not marked with the @Serializable annotation, and if this behavior difference is expected. Please observe the following data class:

@Serializable
data class Test(val value: Int)

and the following manual construction of a JsonObject:

val jsonObject = buildJsonObject {
   put("version", 1)
}

As expected when executing either

Json.decodeFromJsonElement<Test>(jsonObject)

or

Json.decodeFromString<Test>(jsonObject.toString())

the output is an instance of

Test(value=1)

. If the

@Serializable

annotation is removed from the class

Test

and a manual

KSerializer

for the class is created to handle the mapping:

class TestSerializer: KSerializer<Test> {
	override val descriptor: SerialDescriptor
		get() = buildClassSerialDescriptor("test") {
			element<Int>("version")
		}

	override fun deserialize(decoder: Decoder): Test {
		return decoder.decodeStructure(descriptor) {
			val version = decodeIntElement(
				descriptor,
				descriptor.getElementIndex("version")
			)
			Test(version)
		}
	}
    // .... omitting serialize() method
}

then executing

Json.decodeFromJsonElement(TestSerializer(), jsonObject)

will work like before and the output is an instance of

Test(value=1)

just as before. However executing

Json.decodeFromString(TestingSerializer(), jsonObject.toString())

will result in an exception:

Unexpected JSON token at offset 1: Unexpected symbol 'v' in numeric literal at path: $
kotlinx.serialization.json.internal.JsonDecodingException: Unexpected JSON token at offset 1: Unexpected symbol 'v' in numeric literal at path: $
JSON input: {"version":1}

Is this the expected behavior, and if so what is causing the string traversal to fail while the

JsonObject

is not affected?

Issue with polymorphism and KMM: Setup is

interface IFoo 

@Serializable
class FooA: IFoo

@Serializable
class FooB: IFoo

val myJson = Json {
    ignoreUnknownKeys = true
    isLenient = true
    explicitNulls = false
    encodeDefaults = false
    serializersModule = SerializersModule {
        polymorphic(IFoo::class, FooA::class, FooA.serializer())
        polymorphic(IFoo::class, FooB::class, FooB.serializer())
    }
}

val listOfFoo = myJson.decodeFromString<<List<IFoo>>(...)

The above ^ works fine in the Android code, but errors out when called from iOS:

`kotlinx.serialization.SerializationException: Serializer for class ‘IFoo’ is not found.

Mark the class as @Serializable or provide the serializer explicitly.

On Kotlin/Native explicitly declared serializer should be used for interfaces and enums without @Serializable annotation`

Is there a step that I am missing with setting up the SerializersModule to make it compatible with iOS? Again, this works perfectly fine from the Android Versions: • Kotlin: 1.7.10 • Kotlin serialization: 1.4.0 ◦ org.jetbrains.kotlinx:kotlinx-serialization-core ◦ org.jetbrains.kotlinx:kotlinx-serialization-json EDIT: https://kotlinlang.slack.com/archives/C7A1U5PTM/p1601187298013400 I found this older post with someone asking the same question and they seemed to solve it by downgrading ?

Using kotlinx.serialization utilities for constructing JSON representations, I wonder, I got an incoming type with the signature

Map<String, Any?>

and I want to turn it into JSON to then pass somewhere else. With the type-safe builders I only see that I can do stuff like

put(key:Any, value: JsonElement)

but I don’t know how to turn my

Any? -> JsonElement

. I can do stuff like

fun Any.toJsonElement() : JsonElement {
  when(this) {
    is Map<*, *> -> ...
    is Collection<*> -> ...
  }
}

and so on but I’ll most definitely do it wrong so I was looking if there’s some API I’m missing here.

Is there any simple way to use the ordinal of an enum instead of the name for serializing/deserializing?

I've got this data class which works for my data, but I wanna change it up some so its easier to work with. I need to make it so a value of

1

represents it being present, and if its null then its not present. That way it can just be a list of the present `Feature`s

@OptIn(ExperimentalSerializationApi::class)
@Serializable
data class SearchFilter(
    val sortBy: SortBy? = null,
    val filters: List<Filter>
) {
    @Serializable
    data class Filter(
        val uploadDate: UploadDate? = null, // ignore these
        val type: Type? = null, // ignore these
        val duration: Duration? = null, // ignore these
        val hd: Int? = null,
        @ProtoNumber(14)
        val uhd: Int? = null,
        val subtitles: Int? = null,
        val creativeCommons: Int? = null,
        @ProtoNumber(15)
        val spherical: Int? = null,
        @ProtoNumber(26)
        val vr: Int? = null
    )
}

@Serializable
enum class Feature {
    LIVE,
    UHD,
    HD,
    SUBTITLES,
    CREATIVE_COMMONS,
    /** 360° video */
    SPHERICAL,
    VR
}

Hi, is there a way to parse a string containing JSON to a list of associations key to value? I would like to check for duplicate keys in a JSON using such a list so a Map would not help me

Why those "default" R8 rules are not bundled directly in the library? Is there any reason or motivation not to do it? thx

I’m trying to run the tests on the project, using the jvm. Unfortunately, I keep having this error:

> Task :kotlinx-serialization-core:compileKotlinJvm FAILED
e: Module java.base cannot be found in the module graph

I thought it was a problem with my configuration but I tried using version 1.8, 11 and 17 for java and nothing worked. Are there contributors out here who could help me?

Hi, is it possible with kotlinx to deserialize an array with nested cbor encoded data items contained within a map? For example:

text(10)
  "nameSpaces"
map(1)
  text(3)
    "key"
  array(10)
    encoded cbor data item, tag(24)
      bytes(82)
        ...