libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/handshake/CoreSetupDataSerializer.kt

@@ -22,9 +22,11 @@ import de.justjanne.libquassel.protocol.variant.qVariant
 object CoreSetupDataSerializer : HandshakeSerializer<HandshakeMessage.CoreSetupData> {
   override val type: String = "CoreSetupData"
 
-  override fun serialize(data: HandshakeMessage.CoreSetupData) = mapOf(
+  override fun serialize(data: HandshakeMessage.CoreSetupData) =
+    mapOf(
       "MsgType" to qVariant(type, QtType.QString),
-    "SetupData" to qVariant(
+      "SetupData" to
+        qVariant(
           mapOf(
             "AdminUser" to qVariant(data.adminUser, QtType.QString),
             "AdminPasswd" to qVariant(data.adminPassword, QtType.QString),
@@ -33,8 +35,8 @@ object CoreSetupDataSerializer : HandshakeSerializer<HandshakeMessage.CoreSetupD
             "Authenticator" to qVariant(data.authenticator, QtType.QString),
             "AuthProperties" to qVariant(data.authSetupData, QtType.QVariantMap),
           ),
-      QtType.QVariantMap
-    )
+          QtType.QVariantMap,
+        ),
     )
 
   override fun deserialize(data: QVariantMap) =
@@ -45,7 +47,7 @@ object CoreSetupDataSerializer : HandshakeSerializer<HandshakeMessage.CoreSetupD
         backend = it["Backend"].into(),
         setupData = it["ConnectionProperties"].into<QVariantMap>().orEmpty(),
         authenticator = it["Authenticator"].into(),
-        authSetupData = it["AuthProperties"].into<QVariantMap>().orEmpty()
+        authSetupData = it["AuthProperties"].into<QVariantMap>().orEmpty(),
       )
     }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/handshake/CoreSetupRejectSerializer.kt

@@ -22,12 +22,14 @@ import de.justjanne.libquassel.protocol.variant.qVariant
 object CoreSetupRejectSerializer : HandshakeSerializer<HandshakeMessage.CoreSetupReject> {
   override val type: String = "CoreSetupReject"
 
-  override fun serialize(data: HandshakeMessage.CoreSetupReject) = mapOf(
+  override fun serialize(data: HandshakeMessage.CoreSetupReject) =
+    mapOf(
       "MsgType" to qVariant(type, QtType.QString),
-    "Error" to qVariant(data.errorString, QtType.QString)
+      "Error" to qVariant(data.errorString, QtType.QString),
     )
 
-  override fun deserialize(data: QVariantMap) = HandshakeMessage.CoreSetupReject(
-    errorString = data["Error"].into()
+  override fun deserialize(data: QVariantMap) =
+    HandshakeMessage.CoreSetupReject(
+      errorString = data["Error"].into(),
     )
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/handshake/SessionInitSerializer.kt

@@ -12,6 +12,7 @@ package de.justjanne.libquassel.protocol.serializers.handshake
 import de.justjanne.libquassel.protocol.models.BufferInfo
 import de.justjanne.libquassel.protocol.models.HandshakeMessage
 import de.justjanne.libquassel.protocol.models.ids.NetworkId
+import de.justjanne.libquassel.protocol.models.network.IdentityDto
 import de.justjanne.libquassel.protocol.models.types.QtType
 import de.justjanne.libquassel.protocol.models.types.QuasselType
 import de.justjanne.libquassel.protocol.serializers.HandshakeSerializer
@@ -27,43 +28,52 @@ import de.justjanne.libquassel.protocol.variant.qVariant
 object SessionInitSerializer : HandshakeSerializer<HandshakeMessage.SessionInit> {
   override val type: String = "SessionInit"
 
-  override fun serialize(data: HandshakeMessage.SessionInit) = mapOf<String, QVariant_>(
+  override fun serialize(data: HandshakeMessage.SessionInit) =
+    mapOf<String, QVariant_>(
       "MsgType" to qVariant<String>(type, QtType.QString),
-    "SessionState" to qVariant<QVariantMap>(
+      "SessionState" to
+        qVariant<QVariantMap>(
           mapOf(
-        "BufferInfos" to qVariant<QVariantList>(
+            "BufferInfos" to
+              qVariant<QVariantList>(
                 data.bufferInfos.map {
                   qVariant<BufferInfo>(it, QuasselType.BufferInfo)
                 },
-          QtType.QVariantList
+                QtType.QVariantList,
               ),
-        "NetworkIds" to qVariant<QVariantList>(
+            "NetworkIds" to
+              qVariant<QVariantList>(
                 data.networkIds.map {
                   qVariant<NetworkId>(it, QuasselType.NetworkId)
                 },
-          QtType.QVariantList
+                QtType.QVariantList,
               ),
-        "Identities" to qVariant<QVariantList>(
+            "Identities" to
+              qVariant<QVariantList>(
                 data.identities.map {
-            qVariant<QVariantMap>(it, QuasselType.Identity)
+                  qVariant<IdentityDto>(it, QuasselType.Identity)
                 },
-          QtType.QVariantList
+                QtType.QVariantList,
               ),
           ),
-      QtType.QVariantMap
-    )
+          QtType.QVariantMap,
+        ),
     )
 
-  override fun deserialize(data: QVariantMap) = data["SessionState"].into<QVariantMap>().let {
+  override fun deserialize(data: QVariantMap) =
+    data["SessionState"].into<QVariantMap>().let {
       HandshakeMessage.SessionInit(
-      bufferInfos = it?.get("BufferInfos").into<QVariantList>()?.mapNotNull {
+        bufferInfos =
+          it?.get("BufferInfos").into<QVariantList>()?.mapNotNull {
             it.into<BufferInfo>()
           }.orEmpty(),
-      networkIds = it?.get("NetworkIds").into<QVariantList>()?.mapNotNull {
+        networkIds =
+          it?.get("NetworkIds").into<QVariantList>()?.mapNotNull {
             it.into<NetworkId>()
           }.orEmpty(),
-      identities = it?.get("Identities").into<QVariantList>()?.mapNotNull {
-        it.into<QVariantMap>()
+        identities =
+          it?.get("Identities").into<QVariantList>()?.mapNotNull {
+            it.into<IdentityDto>()
           }.orEmpty(),
       )
     }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/BoolSerializer.kt

@@ -20,14 +20,24 @@ import java.nio.ByteBuffer
 object BoolSerializer : PrimitiveSerializer<Boolean> {
   override val javaType: Class<Boolean> = Boolean::class.javaObjectType
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Boolean, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Boolean,
+    featureSet: FeatureSet,
+  ) {
     buffer.put(
-      if (data) 0x01.toByte()
-      else 0x00.toByte()
+      if (data) {
+        0x01.toByte()
+      } else {
+        0x00.toByte()
+      },
     )
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Boolean {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Boolean {
     return buffer.get() != 0x00.toByte()
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/ByteBufferSerializer.kt

@@ -21,7 +21,11 @@ import java.nio.ByteBuffer
 object ByteBufferSerializer : PrimitiveSerializer<ByteBuffer?> {
   override val javaType: Class<out ByteBuffer?> = ByteBuffer::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: ByteBuffer?, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: ByteBuffer?,
+    featureSet: FeatureSet,
+  ) {
     IntSerializer.serialize(buffer, data?.remaining() ?: -1, featureSet)
     if (data != null) {
       buffer.put(data)
@@ -29,7 +33,10 @@ object ByteBufferSerializer : PrimitiveSerializer<ByteBuffer?> {
     data?.rewind()
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): ByteBuffer? {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): ByteBuffer? {
     val length = IntSerializer.deserialize(buffer, featureSet)
     if (length < 0) {
       return null

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/ByteSerializer.kt

@@ -20,11 +20,18 @@ import java.nio.ByteBuffer
 object ByteSerializer : PrimitiveSerializer<Byte> {
   override val javaType: Class<Byte> = Byte::class.javaObjectType
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Byte, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Byte,
+    featureSet: FeatureSet,
+  ) {
     buffer.put(data)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Byte {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Byte {
     return buffer.get()
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/DoubleSerializer.kt

@@ -20,11 +20,18 @@ import java.nio.ByteBuffer
 object DoubleSerializer : PrimitiveSerializer<Double> {
   override val javaType: Class<Double> = Double::class.javaObjectType
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Double, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Double,
+    featureSet: FeatureSet,
+  ) {
     buffer.putDouble(data)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Double {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Double {
     return buffer.getDouble()
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/FloatSerializer.kt

@@ -20,11 +20,18 @@ import java.nio.ByteBuffer
 object FloatSerializer : PrimitiveSerializer<Float> {
   override val javaType: Class<Float> = Float::class.javaObjectType
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Float, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Float,
+    featureSet: FeatureSet,
+  ) {
     buffer.putFloat(data)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Float {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Float {
     return buffer.getFloat()
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/HandshakeMapSerializer.kt

@@ -24,12 +24,16 @@ import java.nio.ByteBuffer
  * which uses a special format instead of [QVariantMapSerializer]
  */
 object HandshakeMapSerializer : PrimitiveSerializer<QVariantMap> {
-
   @Suppress("UNCHECKED_CAST")
   override val javaType: Class<out QVariantMap> = Map::class.java as Class<QVariantMap>
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QVariantMap, featureSet: FeatureSet) {
-    val list: QVariantList = data.entries.flatMap { (key, value) ->
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: QVariantMap,
+    featureSet: FeatureSet,
+  ) {
+    val list: QVariantList =
+      data.entries.flatMap { (key, value) ->
         val encodedKey = StringSerializerUtf8.serializeRaw(key)
         listOf(qVariant(encodedKey, QtType.QByteArray), value)
       }
@@ -37,7 +41,10 @@ object HandshakeMapSerializer : PrimitiveSerializer<QVariantMap> {
     QVariantListSerializer.serialize(buffer, list, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QVariantMap {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): QVariantMap {
     val list = QVariantListSerializer.deserialize(buffer, featureSet)
     return (list.indices step 2).map {
       val encodedKey = list[it].into<ByteBuffer>(ByteBuffer.allocateDirect(0))

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/IntSerializer.kt

@@ -20,11 +20,18 @@ import java.nio.ByteBuffer
 object IntSerializer : PrimitiveSerializer<Int> {
   override val javaType: Class<Int> = Int::class.javaObjectType
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Int, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Int,
+    featureSet: FeatureSet,
+  ) {
     buffer.putInt(data)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Int {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Int {
     return buffer.getInt()
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/LongSerializer.kt

@@ -20,11 +20,18 @@ import java.nio.ByteBuffer
 object LongSerializer : PrimitiveSerializer<Long> {
   override val javaType: Class<Long> = Long::class.javaObjectType
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Long, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Long,
+    featureSet: FeatureSet,
+  ) {
     buffer.putLong(data)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Long {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Long {
     return buffer.getLong()
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QCharSerializer.kt

@@ -23,13 +23,21 @@ object QCharSerializer : PrimitiveSerializer<Char> {
   override val javaType: Class<out Char> = Char::class.javaObjectType
 
   private val encoderLocal = ThreadLocal<StringEncoder>()
+
   private fun encoder() = encoderLocal.getOrSet { StringEncoder(Charsets.UTF_16BE) }
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Char, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Char,
+    featureSet: FeatureSet,
+  ) {
     buffer.put(encoder().encodeChar(data))
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Char {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Char {
     return encoder().decodeChar(buffer)
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QDateSerializer.kt

@@ -22,12 +22,19 @@ import java.nio.ByteBuffer
 object QDateSerializer : PrimitiveSerializer<LocalDate> {
   override val javaType: Class<out LocalDate> = LocalDate::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: LocalDate, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: LocalDate,
+    featureSet: FeatureSet,
+  ) {
     val julianDay = data.getLong(JulianFields.JULIAN_DAY).toInt()
     IntSerializer.serialize(buffer, julianDay, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): LocalDate {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): LocalDate {
     val julianDay = IntSerializer.deserialize(buffer, featureSet).toLong()
     return LocalDate.ofEpochDay(0).with(JulianFields.JULIAN_DAY, julianDay)
   }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QDateTimeSerializer.kt

@@ -28,8 +28,16 @@ import java.nio.ByteBuffer
 object QDateTimeSerializer : PrimitiveSerializer<Temporal> {
   override val javaType: Class<out Temporal> = Temporal::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Temporal, featureSet: FeatureSet) {
-    fun serialize(data: LocalDateTime, timeSpec: TimeSpec, offset: ZoneOffset?) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Temporal,
+    featureSet: FeatureSet,
+  ) {
+    fun serialize(
+      data: LocalDateTime,
+      timeSpec: TimeSpec,
+      offset: ZoneOffset?,
+    ) {
       QDateSerializer.serialize(buffer, data.toLocalDate(), featureSet)
       QTimeSerializer.serialize(buffer, data.toLocalTime(), featureSet)
       ByteSerializer.serialize(buffer, timeSpec.value, featureSet)
@@ -60,16 +68,21 @@ object QDateTimeSerializer : PrimitiveSerializer<Temporal> {
     }
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): OffsetDateTime {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): OffsetDateTime {
     val julianDay = QDateSerializer.deserialize(buffer, featureSet)
     val localTime = QTimeSerializer.deserialize(buffer, featureSet)
     val localDateTime = LocalDateTime.of(julianDay, localTime)
-    val timeSpec = TimeSpec.of(ByteSerializer.deserialize(buffer, featureSet))
+    val timeSpec =
+      TimeSpec.of(ByteSerializer.deserialize(buffer, featureSet))
         ?: TimeSpec.LocalUnknown
     return when (timeSpec) {
       TimeSpec.LocalStandard,
       TimeSpec.LocalUnknown,
-      TimeSpec.LocalDST ->
+      TimeSpec.LocalDST,
+      ->
         localDateTime.atZone(ZoneId.systemDefault()).toOffsetDateTime()
       TimeSpec.OffsetFromUTC ->
         localDateTime.atOffset(ZoneOffset.ofTotalSeconds(IntSerializer.deserialize(buffer, featureSet)))

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QStringListSerializer.kt

@@ -19,18 +19,24 @@ import java.nio.ByteBuffer
  * Serializer for [QStringList]
  */
 object QStringListSerializer : PrimitiveSerializer<QStringList> {
-
   @Suppress("UNCHECKED_CAST")
   override val javaType: Class<QStringList> = List::class.java as Class<QStringList>
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QStringList, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: QStringList,
+    featureSet: FeatureSet,
+  ) {
     IntSerializer.serialize(buffer, data.size, featureSet)
     data.forEach {
       StringSerializerUtf16.serialize(buffer, it, featureSet)
     }
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QStringList {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): QStringList {
     val result = mutableListOf<String?>()
     val length = IntSerializer.deserialize(buffer, featureSet)
     for (i in 0 until length) {

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QTimeSerializer.kt

@@ -21,12 +21,19 @@ import java.nio.ByteBuffer
 object QTimeSerializer : PrimitiveSerializer<LocalTime> {
   override val javaType: Class<out LocalTime> = LocalTime::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: LocalTime, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: LocalTime,
+    featureSet: FeatureSet,
+  ) {
     val millisecondOfDay = (data.toNanoOfDay() / 1_000_000).toInt()
     IntSerializer.serialize(buffer, millisecondOfDay, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): LocalTime {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): LocalTime {
     val millisecondOfDay = IntSerializer.deserialize(buffer, featureSet).toLong()
     try {
       return LocalTime.ofNanoOfDay(millisecondOfDay * 1_000_000)

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QVariantListSerializer.kt

@@ -20,18 +20,24 @@ import java.nio.ByteBuffer
  * Serializer for [QVariantList]
  */
 object QVariantListSerializer : PrimitiveSerializer<QVariantList> {
-
   @Suppress("UNCHECKED_CAST")
   override val javaType: Class<QVariantList> = List::class.java as Class<QVariantList>
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QVariantList, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: QVariantList,
+    featureSet: FeatureSet,
+  ) {
     IntSerializer.serialize(buffer, data.size, featureSet)
     data.forEach {
       QVariantSerializer.serialize(buffer, it, featureSet)
     }
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QVariantList {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): QVariantList {
     val result = mutableListOf<QVariant_>()
     val length = IntSerializer.deserialize(buffer, featureSet)
     for (i in 0 until length) {

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QVariantMapSerializer.kt

@@ -20,11 +20,14 @@ import java.nio.ByteBuffer
  * Serializer for [QVariantMap]
  */
 object QVariantMapSerializer : PrimitiveSerializer<QVariantMap> {
-
   @Suppress("UNCHECKED_CAST")
   override val javaType: Class<out QVariantMap> = Map::class.java as Class<QVariantMap>
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QVariantMap, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: QVariantMap,
+    featureSet: FeatureSet,
+  ) {
     IntSerializer.serialize(buffer, data.size, featureSet)
     data.entries.forEach { (key, value) ->
       StringSerializerUtf16.serialize(buffer, key, featureSet)
@@ -32,7 +35,10 @@ object QVariantMapSerializer : PrimitiveSerializer<QVariantMap> {
     }
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QVariantMap {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): QVariantMap {
     val result = mutableMapOf<String, QVariant_>()
     val length = IntSerializer.deserialize(buffer, featureSet)
     for (i in 0 until length) {

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/QVariantSerializer.kt

@@ -25,7 +25,11 @@ import java.nio.ByteBuffer
 object QVariantSerializer : PrimitiveSerializer<QVariant_> {
   override val javaType: Class<QVariant_> = QVariant::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QVariant_, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: QVariant_,
+    featureSet: FeatureSet,
+  ) {
     when (data) {
       is QVariant.Typed -> {
         IntSerializer.serialize(buffer, data.type.id, featureSet)
@@ -41,16 +45,21 @@ object QVariantSerializer : PrimitiveSerializer<QVariant_> {
     }
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QVariant_ {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): QVariant_ {
     val rawType = IntSerializer.deserialize(buffer, featureSet)
-    val qtType = QtType.of(rawType)
+    val qtType =
+      QtType.of(rawType)
         ?: throw NoSerializerForTypeException.Qt(rawType, null)
     // isNull, but we ignore it as it has no meaning
     BoolSerializer.deserialize(buffer, featureSet)
 
     return if (qtType == QtType.UserType) {
       val name = StringSerializerAscii.deserialize(buffer, featureSet)
-      val quasselType = QuasselType.of(name)
+      val quasselType =
+        QuasselType.of(name)
           ?: throw NoSerializerForTypeException.Quassel(qtType.id, name)
       deserialize(quasselType, buffer, featureSet)
     } else {
@@ -59,8 +68,13 @@ object QVariantSerializer : PrimitiveSerializer<QVariant_> {
   }
 
   @Suppress("UNCHECKED_CAST")
-  private fun deserialize(type: QtType, buffer: ByteBuffer, featureSet: FeatureSet): QVariant_ {
-    val serializer = type.serializer
+  private fun deserialize(
+    type: QtType,
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): QVariant_ {
+    val serializer =
+      type.serializer
         as? PrimitiveSerializer<Any>
         ?: throw NoSerializerForTypeException.Qt(type)
     val value = serializer.deserialize(buffer, featureSet)
@@ -68,8 +82,13 @@ object QVariantSerializer : PrimitiveSerializer<QVariant_> {
   }
 
   @Suppress("UNCHECKED_CAST")
-  private fun deserialize(type: QuasselType, buffer: ByteBuffer, featureSet: FeatureSet): QVariant_ {
-    val serializer = type.serializer
+  private fun deserialize(
+    type: QuasselType,
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): QVariant_ {
+    val serializer =
+      type.serializer
         as? PrimitiveSerializer<Any>
         ?: throw NoSerializerForTypeException.Quassel(type)
     val value = serializer.deserialize(buffer, featureSet)

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/qt/ShortSerializer.kt

@@ -20,11 +20,18 @@ import java.nio.ByteBuffer
 object ShortSerializer : PrimitiveSerializer<Short> {
   override val javaType: Class<Short> = Short::class.javaObjectType
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Short, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Short,
+    featureSet: FeatureSet,
+  ) {
     buffer.putShort(data)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Short {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Short {
     return buffer.getShort()
   }
 }