Hi, how could I serialize a collection of this structure :

data class Advancement(val name: String, val done: Boolean = false, val criteria: Map<String, Boolean> = mapOf())

As a map with advancements name as keys and

done

as value if

criteria

is empty, else as the map itself (totally ignoring

done

) ?

what about if

done

was a property of the class, and was annotated with

@EncodeDefault

?

@Serializable
data class Advancement(
  val name: String, 
  val criteria: Map<String, Boolean> = mapOf()
) {
  @OptIn(ExperimentalSerializationApi::class)
  @EncodeDefault
  val done: Boolean get() = criteria.isEmpty()
}

if

criteria

is empty, then it matches the default value, so shouldn’t be encoded. Whereas

done

will always be encoded, which doesn’t quite match your criteria, but I think it’s close enough. Anything more could be quite complicated!

I can't because

done

can also be changed explicitly

Hmm… so what should happen if

done

is set to

false

and the map isn’t empty?

Then the map take the priority

what about if

done

is set as

true

?

If the map is not empty then it takes the priority. It's because I need a json entry where the value could be a boolean or an objet containing multiple boolean entries, so I've done it that way in Kotlin, maybe there's a better way but I don't know it then

can you share the Kotlin code? I’m finding it tough to figure out the logic

There is no code for this right now, I didn't started to use it, I just created the data class you see upper

ah okay

My JSON entry could be this :

"minecraft:my_advancement": true

Or this :

"minecraft:my_advancement": {
    "condition1": false,
    "condition2": true
}

since it’s JSON you could look into

JsonTransformingSerializer

https://github.com/Kotlin/kotlinx.serialization/blob/v1.4.1/docs/json.md#json-transformations

yes I know, but I can't figure out how to create a serializer like this, that was was I posted my message, to get some help creating it

ahh okay, so the data is a key-value map, and the value can either be 1. a boolean or 2. a string-boolean map

Exactly !

so basically this is ‘sealed polymorphism’. The data can have multiple types, but it’s restricted to a limited number of types. What’s usually nice in these situations is to be explicit and avoid generics (because generics are usually open polymorphism), and create a sealed interface that both types inherit

@Serializable
sealed interface Advancement {
  val name: String

  @Serializable
  data class Simple(
    override val name: String,
    val value: Boolean,
  ) : Advancement

  @Serializable
  data class Complex(
    override val name: String,
    val value: Map<String, Boolean>,
  ) : Advancement
}

Also I don't really need deserialization, if It's easy to implement then I'll implement it, but currently my program don't use deserialization at all !

How about this, delegating to a normal map serializer?

object AdvancementSerializer : SerializationStrategy<Advancement> {
    private val mapSerializer = MapSerializer(String.serializer(), Boolean.serializer())

    override val descriptor: SerialDescriptor =
        SerialDescriptor("my.package.Advancement", mapSerializer.descriptor)

    override fun serialize(encoder: Encoder, value: Advancement) {
        val map = if (value.criteria.isEmpty()) {
            mapOf(value.name to value.done)
        } else {
            value.criteria
        }

        encoder.encodeSerializableValue(mapSerializer, map)
    }
}

Sorry but what is a SerializationStrategy ? How do I use it to specify the serializer of a property ?

Oh, KSerializer implements that and DeserializationStrategy, so it's just the serializing half. I'm not sure if there's a proper way, since

@Serializable

doesn't accept SerializationStrategy, but you can change my serializer to implement KSerializer and throw an error when deserializing

I see, thanks !