A modern programming language that makes developers happier.

kotlinlang

```abstract class MapNode {

    // Node Properties
    var isGroup by mutableStateOf(false)
    var colorIndex by mutableStateOf(0)

    // Node Children
    @Serializable(with = SnapshotStateListSerializer::class)
    var left = mutableStateListOf&lt;MapNode&gt;()

}```
*How can I write a Custom Serializer for this class ??* that serializes all these properties ! (including delegated properties)

You could serialize it using a wrapper class.

Make the same class without delagates. `data class MapNode(val .....)` .

but then I would need to convert classes and apply properties before serialization

are you suggesting Surrogate Serializer...

Yeah you would need to convert but it saves you having to wr..... eEXCACTLY!!!

It saves you having to write a custom serializer.

Or rather, a complex one. With a surrogate you can keep it simple.

Thanks ! I'll try it
and let you know if it works

```@SerialName("MapNode")
@Serializable
private class MapNodeSurrogate(
    val isGroup: Boolean,
    val colorIndex: Int,
    val left: List&lt;MapNodeSurrogate&gt;,
    val right: List&lt;MapNodeSurrogate&gt;
)

object MapNodeSerializer : KSerializer&lt;MapNode&gt; {

    private val serializer = MapNodeSurrogate.serializer()

    override val descriptor: SerialDescriptor = serializer.descriptor

    private fun convertToSurrogate(node: MapNode): MapNodeSurrogate {
        return MapNodeSurrogate(
            node.isGroup,
            node.colorIndex,
            node.left.map { convertToSurrogate(it) },
            node.right.map { convertToSurrogate(it) }
        )
    }

    private fun convertToNode(surrogate: MapNodeSurrogate): MapNode {
        return MapNode().apply {

        }
    }

    override fun serialize(encoder: Encoder, value: MapNode) {
        encoder.encodeSerializableValue(serializer, convertToSurrogate(value))
    }

    override fun deserialize(decoder: Decoder): MapNode {
        return convertToNode(decoder.decodeSerializableValue(serializer))
    }

}```
Since map node is an abstract class , how can I make an instance , I don't know how to deal with polymorphism here

You should make the surrogate polymorphic too.

To save you some time, make sure all of the base class properties are abstract.

I still have to return instance of base class in serializer in deserialize method

how to know which subclass I should return instance of ?

`if (surrogate is SubClassSurrogate) { return subclass }`

```MapNodeSurrogate.serializer()```
still accessing the base class serializer and using it , won't subclass properties not get serialized ?

It'll be fine. As long as you've registered the subclasses.