```abstract class MapNode { // Node Properties var isGroup by mutableStateOf(false) var...

# serialization

[Waqas Tahir]

abstract class MapNode {

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

    // Node Children
    @Serializable(with = SnapshotStateListSerializer::class)
    var left = mutableStateListOf<MapNode>()

}

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

[Dominaezzz]

You could serialize it using a wrapper class.

[Waqas Tahir]

how ?

[Waqas Tahir]

I've tried everything

[Dominaezzz]

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

[Dominaezzz]

Then serialize that. super easy,.

[Waqas Tahir]

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

[Waqas Tahir]

won't I?

[Waqas Tahir]

are you suggesting Surrogate Serializer...

[Dominaezzz]

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

[Dominaezzz]

Surrogate!

[Dominaezzz]

It saves you having to write a custom serializer.

[Dominaezzz]

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

[Waqas Tahir]

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

[Waqas Tahir]

@SerialName("MapNode")
@Serializable
private class MapNodeSurrogate(
    val isGroup: Boolean,
    val colorIndex: Int,
    val left: List<MapNodeSurrogate>,
    val right: List<MapNodeSurrogate>
)

object MapNodeSerializer : KSerializer<MapNode> {

    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

[Dominaezzz]

You should make the surrogate polymorphic too.

[Dominaezzz]

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

[Waqas Tahir]

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

[Dominaezzz]

Yes?

[Waqas Tahir]

how to know which subclass I should return instance of ?

[Dominaezzz]

You can get that from the surrogate.

[Dominaezzz]

if (surrogate is SubClassSurrogate) { return subclass }

[Waqas Tahir]

ok

[Waqas Tahir]

MapNodeSurrogate.serializer()

still accessing the base class serializer and using it , won't subclass properties not get serialized ?

[Dominaezzz]

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

[Waqas Tahir]

It works ! Thanks