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

@@ -29,12 +29,18 @@ abstract class StringSerializer(
   override val javaType: Class<out String> = String::class.java
 
   private val encoderLocal = ThreadLocal<StringEncoder>()
+
   private fun encoder() = encoderLocal.getOrSet { StringEncoder(charset) }
 
   private fun addNullBytes(before: Int) = if (nullLimited) before + 1 else before
+
   private fun removeNullBytes(before: Int) = if (nullLimited) before - 1 else before
 
-  override fun serialize(buffer: ChainedByteBuffer, data: String?, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: String?,
+    featureSet: FeatureSet,
+  ) {
     if (data == null) {
       IntSerializer.serialize(buffer, -1, featureSet)
     } else {
@@ -47,7 +53,10 @@ abstract class StringSerializer(
     }
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): String? {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): String? {
     val length = IntSerializer.deserialize(buffer, featureSet)
     if (length < 0) {
       return null

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

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

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

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

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

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

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

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

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

@@ -21,13 +21,20 @@ import java.util.UUID
 object UuidSerializer : PrimitiveSerializer<UUID> {
   override val javaType: Class<UUID> = UUID::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: UUID, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: UUID,
+    featureSet: FeatureSet,
+  ) {
     LongSerializer.serialize(buffer, data.mostSignificantBits, featureSet)
     LongSerializer.serialize(buffer, data.leastSignificantBits, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet) = UUID(
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ) = UUID(
+    LongSerializer.deserialize(buffer, featureSet),
     LongSerializer.deserialize(buffer, featureSet),
-    LongSerializer.deserialize(buffer, featureSet)
   )
 }

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

@@ -20,6 +20,14 @@ import java.nio.ByteBuffer
 object VoidSerializer : PrimitiveSerializer<Unit> {
   override val javaType: Class<out Unit> = Unit::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Unit, featureSet: FeatureSet) = Unit
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet) = Unit
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Unit,
+    featureSet: FeatureSet,
+  ) = Unit
+
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ) = Unit
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/BufferIdSerializer.kt

@@ -22,11 +22,18 @@ import java.nio.ByteBuffer
 object BufferIdSerializer : PrimitiveSerializer<BufferId> {
   override val javaType: Class<out BufferId> = BufferId::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: BufferId, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: BufferId,
+    featureSet: FeatureSet,
+  ) {
     IntSerializer.serialize(buffer, data.id, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): BufferId {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): BufferId {
     return BufferId(IntSerializer.deserialize(buffer, featureSet))
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/BufferInfoSerializer.kt

@@ -27,7 +27,11 @@ import java.nio.ByteBuffer
 object BufferInfoSerializer : PrimitiveSerializer<BufferInfo> {
   override val javaType: Class<out BufferInfo> = BufferInfo::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: BufferInfo, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: BufferInfo,
+    featureSet: FeatureSet,
+  ) {
     BufferIdSerializer.serialize(buffer, data.bufferId, featureSet)
     NetworkIdSerializer.serialize(buffer, data.networkId, featureSet)
     UShortSerializer.serialize(buffer, data.type.toBits(), featureSet)
@@ -35,7 +39,10 @@ object BufferInfoSerializer : PrimitiveSerializer<BufferInfo> {
     StringSerializerUtf8.serialize(buffer, data.bufferName, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): BufferInfo {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): BufferInfo {
     val bufferId = BufferIdSerializer.deserialize(buffer, featureSet)
     val networkId = NetworkIdSerializer.deserialize(buffer, featureSet)
     val type = BufferType.of(UShortSerializer.deserialize(buffer, featureSet))
@@ -46,7 +53,7 @@ object BufferInfoSerializer : PrimitiveSerializer<BufferInfo> {
       networkId = networkId,
       type = type,
       groupId = groupId,
-      bufferName = bufferName
+      bufferName = bufferName,
     )
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/DccIpDetectionModeSerializer.kt

@@ -20,21 +20,20 @@ import java.nio.ByteBuffer
  * Serializer for [DccIpDetectionMode]
  */
 object DccIpDetectionModeSerializer : PrimitiveSerializer<DccIpDetectionMode?> {
-
   override val javaType: Class<out DccIpDetectionMode?> =
     DccIpDetectionMode::class.java
 
   override fun serialize(
     buffer: ChainedByteBuffer,
     data: DccIpDetectionMode?,
-    featureSet: FeatureSet
+    featureSet: FeatureSet,
   ) {
     UByteSerializer.serialize(buffer, data?.value ?: 0x00u, featureSet)
   }
 
   override fun deserialize(
     buffer: ByteBuffer,
-    featureSet: FeatureSet
+    featureSet: FeatureSet,
   ): DccIpDetectionMode? {
     return DccIpDetectionMode.of(UByteSerializer.deserialize(buffer, featureSet))
   }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/DccPortSelectionModeSerializer.kt

@@ -20,21 +20,20 @@ import java.nio.ByteBuffer
  * Serializer for [DccPortSelectionMode]
  */
 object DccPortSelectionModeSerializer : PrimitiveSerializer<DccPortSelectionMode?> {
-
   override val javaType: Class<out DccPortSelectionMode?> =
     DccPortSelectionMode::class.java
 
   override fun serialize(
     buffer: ChainedByteBuffer,
     data: DccPortSelectionMode?,
-    featureSet: FeatureSet
+    featureSet: FeatureSet,
   ) {
     UByteSerializer.serialize(buffer, data?.value ?: 0x00u, featureSet)
   }
 
   override fun deserialize(
     buffer: ByteBuffer,
-    featureSet: FeatureSet
+    featureSet: FeatureSet,
   ): DccPortSelectionMode? {
     return DccPortSelectionMode.of(UByteSerializer.deserialize(buffer, featureSet))
   }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/IdentityIdSerializer.kt

@@ -22,11 +22,18 @@ import java.nio.ByteBuffer
 object IdentityIdSerializer : PrimitiveSerializer<IdentityId> {
   override val javaType: Class<out IdentityId> = IdentityId::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: IdentityId, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: IdentityId,
+    featureSet: FeatureSet,
+  ) {
     IntSerializer.serialize(buffer, data.id, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): IdentityId {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): IdentityId {
     return IdentityId(IntSerializer.deserialize(buffer, featureSet))
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/IdentitySerializer.kt

 /*
  * libquassel
- * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2024 Janne Mareike Koschinski
  *
  * This Source Code Form is subject to the terms of the Mozilla Public License,
  * v. 2.0. If a copy of the MPL was not distributed with this file, You can
@@ -11,23 +11,78 @@ package de.justjanne.libquassel.protocol.serializers.quassel
 
 import de.justjanne.libquassel.protocol.features.FeatureSet
 import de.justjanne.libquassel.protocol.io.ChainedByteBuffer
+import de.justjanne.libquassel.protocol.models.ids.IdentityId
+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.PrimitiveSerializer
 import de.justjanne.libquassel.protocol.serializers.qt.QVariantMapSerializer
-import de.justjanne.libquassel.protocol.syncables.common.Identity
 import de.justjanne.libquassel.protocol.variant.QVariantMap
+import de.justjanne.libquassel.protocol.variant.into
+import de.justjanne.libquassel.protocol.variant.qVariant
 import java.nio.ByteBuffer
 
-/**
- * Serializer for [QVariantMap], with custom name for [Identity]
- */
-object IdentitySerializer : PrimitiveSerializer<QVariantMap> {
+object IdentitySerializer : PrimitiveSerializer<IdentityDto> {
+  override val javaType: Class<IdentityDto> = IdentityDto::class.java
+
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: IdentityDto,
+    featureSet: FeatureSet,
+  ) {
+    QVariantMapSerializer.serialize(buffer, toMap(data), featureSet)
+  }
 
-  @Suppress("UNCHECKED_CAST")
-  override val javaType: Class<out QVariantMap> = Map::class.java as Class<QVariantMap>
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): IdentityDto {
+    return fromMap(QVariantMapSerializer.deserialize(buffer, featureSet))
+  }
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QVariantMap, featureSet: FeatureSet) =
-    QVariantMapSerializer.serialize(buffer, data, featureSet)
+  private fun toMap(data: IdentityDto): QVariantMap =
+    mapOf(
+      "identityId" to qVariant(data.identityId, QuasselType.IdentityId),
+      "identityName" to qVariant(data.identityName, QtType.QString),
+      "realName" to qVariant(data.realName, QtType.QString),
+      "nicks" to qVariant(data.nicks, QtType.QStringList),
+      "awayNick" to qVariant(data.awayNick, QtType.QString),
+      "awayNickEnabled" to qVariant(data.awayNickEnabled, QtType.Bool),
+      "awayReason" to qVariant(data.awayReason, QtType.QString),
+      "awayReasonEnabled" to qVariant(data.awayReasonEnabled, QtType.Bool),
+      "autoAwayEnabled" to qVariant(data.autoAwayEnabled, QtType.Bool),
+      "autoAwayTime" to qVariant(data.autoAwayTime, QtType.Int),
+      "autoAwayReason" to qVariant(data.autoAwayReason, QtType.QString),
+      "autoAwayReasonEnabled" to qVariant(data.autoAwayReasonEnabled, QtType.Bool),
+      "detachAwayEnabled" to qVariant(data.detachAwayEnabled, QtType.Bool),
+      "detachAwayReason" to qVariant(data.detachAwayReason, QtType.QString),
+      "detachAwayReasonEnabled" to qVariant(data.detachAwayReasonEnabled, QtType.Bool),
+      "ident" to qVariant(data.ident, QtType.QString),
+      "kickReason" to qVariant(data.kickReason, QtType.QString),
+      "partReason" to qVariant(data.partReason, QtType.QString),
+      "quitReason" to qVariant(data.quitReason, QtType.QString),
+    )
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QVariantMap =
-    QVariantMapSerializer.deserialize(buffer, featureSet)
+  private fun fromMap(data: QVariantMap) =
+    IdentityDto(
+      identityId = data["identityId"].into(IdentityId(-1)),
+      identityName = data["identityName"].into("<empty>"),
+      realName = data["realName"].into(""),
+      nicks = data["nicks"].into(listOf("quassel")),
+      awayNick = data["awayNick"].into(""),
+      awayNickEnabled = data["awayNickEnabled"].into(false),
+      awayReason = data["awayReason"].into("Gone fishing."),
+      awayReasonEnabled = data["awayReasonEnabled"].into(true),
+      autoAwayEnabled = data["autoAwayEnabled"].into(false),
+      autoAwayTime = data["autoAwayTime"].into(10),
+      autoAwayReason = data["autoAwayReason"].into("Not here. No really. not here!"),
+      autoAwayReasonEnabled = data["autoAwayReasonEnabled"].into(false),
+      detachAwayEnabled = data["detachAwayEnabled"].into(false),
+      detachAwayReason = data["detachAwayReason"].into("All Quassel clients vanished from the face of the earth..."),
+      detachAwayReasonEnabled = data["detachAwayReasonEnabled"].into(false),
+      ident = data["ident"].into("quassel"),
+      kickReason = data["kickReason"].into("Kindergarten is elsewhere!"),
+      partReason = data["partReason"].into("http://quassel-irc.org - Chat comfortably. Anywhere."),
+      quitReason = data["quitReason"].into("http://quassel-irc.org - Chat comfortably. Anywhere."),
+    )
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/IrcChannelSerializer.kt

 /*
  * libquassel
- * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2024 Janne Mareike Koschinski
  *
  * This Source Code Form is subject to the terms of the Mozilla Public License,
  * v. 2.0. If a copy of the MPL was not distributed with this file, You can
@@ -11,23 +11,66 @@ package de.justjanne.libquassel.protocol.serializers.quassel
 
 import de.justjanne.libquassel.protocol.features.FeatureSet
 import de.justjanne.libquassel.protocol.io.ChainedByteBuffer
+import de.justjanne.libquassel.protocol.models.network.ChannelModes
+import de.justjanne.libquassel.protocol.models.network.IrcChannelDto
+import de.justjanne.libquassel.protocol.models.types.QtType
 import de.justjanne.libquassel.protocol.serializers.PrimitiveSerializer
 import de.justjanne.libquassel.protocol.serializers.qt.QVariantMapSerializer
-import de.justjanne.libquassel.protocol.syncables.common.IrcChannel
 import de.justjanne.libquassel.protocol.variant.QVariantMap
+import de.justjanne.libquassel.protocol.variant.into
+import de.justjanne.libquassel.protocol.variant.qVariant
 import java.nio.ByteBuffer
 
-/**
- * Serializer for [QVariantMap], with custom name for [IrcChannel]
- */
-object IrcChannelSerializer : PrimitiveSerializer<QVariantMap> {
+object IrcChannelSerializer : PrimitiveSerializer<IrcChannelDto> {
+  override val javaType: Class<IrcChannelDto> = IrcChannelDto::class.java
+
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: IrcChannelDto,
+    featureSet: FeatureSet,
+  ) {
+    QVariantMapSerializer.serialize(buffer, toMap(data), featureSet)
+  }
 
-  @Suppress("UNCHECKED_CAST")
-  override val javaType: Class<out QVariantMap> = Map::class.java as Class<QVariantMap>
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): IrcChannelDto {
+    return fromMap(QVariantMapSerializer.deserialize(buffer, featureSet))
+  }
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QVariantMap, featureSet: FeatureSet) =
-    QVariantMapSerializer.serialize(buffer, data, featureSet)
+  private fun toMap(data: IrcChannelDto): QVariantMap =
+    mapOf(
+      "name" to qVariant(data.name, QtType.QString),
+      "topic" to qVariant(data.topic, QtType.QString),
+      "password" to qVariant(data.password, QtType.QString),
+      "encrypted" to qVariant(data.encrypted, QtType.Bool),
+      "ChanModes" to
+        qVariant(
+          data.channelModes.toVariantMap(),
+          QtType.QVariantMap,
+        ),
+      "UserModes" to
+        qVariant(
+          data.userModes.mapValues { (_, value) ->
+            qVariant(value.joinToString(), QtType.QString)
+          },
+          QtType.QVariantMap,
+        ),
+    )
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QVariantMap =
-    QVariantMapSerializer.deserialize(buffer, featureSet)
+  private fun fromMap(data: QVariantMap) =
+    IrcChannelDto(
+      name = data["name"].into(""),
+      topic = data["topic"].into(""),
+      password = data["password"].into(""),
+      encrypted = data["encrypted"].into(false),
+      channelModes =
+        data["ChanModes"].into<QVariantMap>()
+          ?.let(ChannelModes.Companion::fromVariantMap)
+          ?: ChannelModes(),
+      userModes =
+        data["UserModes"].into<QVariantMap>(emptyMap())
+          .mapValues { (_, value) -> value.into<String>()?.toSet().orEmpty() },
+    )
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/IrcUserSerializer.kt

 /*
  * libquassel
- * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2024 Janne Mareike Koschinski
  *
  * This Source Code Form is subject to the terms of the Mozilla Public License,
  * v. 2.0. If a copy of the MPL was not distributed with this file, You can
@@ -11,23 +11,79 @@ package de.justjanne.libquassel.protocol.serializers.quassel
 
 import de.justjanne.libquassel.protocol.features.FeatureSet
 import de.justjanne.libquassel.protocol.io.ChainedByteBuffer
+import de.justjanne.libquassel.protocol.models.network.IrcUserDto
+import de.justjanne.libquassel.protocol.models.types.QtType
 import de.justjanne.libquassel.protocol.serializers.PrimitiveSerializer
 import de.justjanne.libquassel.protocol.serializers.qt.QVariantMapSerializer
-import de.justjanne.libquassel.protocol.syncables.common.IrcUser
 import de.justjanne.libquassel.protocol.variant.QVariantMap
+import de.justjanne.libquassel.protocol.variant.into
+import de.justjanne.libquassel.protocol.variant.qVariant
+import org.threeten.bp.Instant
+import org.threeten.bp.OffsetDateTime
+import org.threeten.bp.ZoneOffset
 import java.nio.ByteBuffer
 
-/**
- * Serializer for [QVariantMap], with custom name for [IrcUser]
- */
-object IrcUserSerializer : PrimitiveSerializer<QVariantMap> {
+object IrcUserSerializer : PrimitiveSerializer<IrcUserDto> {
+  override val javaType: Class<IrcUserDto> = IrcUserDto::class.java
+
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: IrcUserDto,
+    featureSet: FeatureSet,
+  ) {
+    QVariantMapSerializer.serialize(buffer, toMap(data), featureSet)
+  }
 
-  @Suppress("UNCHECKED_CAST")
-  override val javaType: Class<out QVariantMap> = Map::class.java as Class<QVariantMap>
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): IrcUserDto {
+    return fromMap(QVariantMapSerializer.deserialize(buffer, featureSet))
+  }
 
-  override fun serialize(buffer: ChainedByteBuffer, data: QVariantMap, featureSet: FeatureSet) =
-    QVariantMapSerializer.serialize(buffer, data, featureSet)
+  private fun toMap(data: IrcUserDto): QVariantMap =
+    mapOf(
+      "nick" to qVariant(data.nick, QtType.QString),
+      "user" to qVariant(data.user, QtType.QString),
+      "host" to qVariant(data.host, QtType.QString),
+      "realName" to qVariant(data.realName, QtType.QString),
+      "account" to qVariant(data.account, QtType.QString),
+      "away" to qVariant(data.away, QtType.Bool),
+      "awayMessage" to qVariant(data.awayMessage, QtType.QString),
+      "idleTime" to qVariant(data.idleTime.atOffset(ZoneOffset.UTC), QtType.QDateTime),
+      "loginTime" to qVariant(data.loginTime.atOffset(ZoneOffset.UTC), QtType.QDateTime),
+      "server" to qVariant(data.server, QtType.QString),
+      "ircOperator" to qVariant(data.ircOperator, QtType.QString),
+      "lastAwayMessage" to qVariant(data.lastAwayMessageTime.epochSecond.toInt(), QtType.Int),
+      "lastAwayMessageTime" to qVariant(data.lastAwayMessageTime.atOffset(ZoneOffset.UTC), QtType.QDateTime),
+      "whoisServiceReply" to qVariant(data.whoisServiceReply, QtType.QString),
+      "suserHost" to qVariant(data.suserHost, QtType.QString),
+      "encrypted" to qVariant(data.encrypted, QtType.Bool),
+      "channels" to qVariant(data.channels.toList(), QtType.QStringList),
+      "userModes" to qVariant(data.userModes.joinToString(), QtType.QString),
+    )
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): QVariantMap =
-    QVariantMapSerializer.deserialize(buffer, featureSet)
+  private fun fromMap(data: QVariantMap) =
+    IrcUserDto(
+      nick = data["nick"].into(""),
+      user = data["user"].into(""),
+      host = data["host"].into(""),
+      realName = data["realName"].into(""),
+      account = data["account"].into(""),
+      away = data["away"].into(false),
+      awayMessage = data["awayMessage"].into(""),
+      idleTime = data["idleTime"].into(Instant.EPOCH.atOffset(ZoneOffset.UTC)).toInstant(),
+      loginTime = data["loginTime"].into(Instant.EPOCH.atOffset(ZoneOffset.UTC)).toInstant(),
+      server = data["server"].into(""),
+      ircOperator = data["ircOperator"].into(""),
+      lastAwayMessageTime =
+        data["lastAwayMessageTime"].into<OffsetDateTime>()?.toInstant()
+          ?: data["lastAwayMessage"].into<Int>()?.toLong()?.let(Instant::ofEpochSecond)
+          ?: Instant.EPOCH,
+      whoisServiceReply = data["whoisServiceReply"].into(""),
+      suserHost = data["suserHost"].into(""),
+      encrypted = data["encrypted"].into(false),
+      channels = data["channels"].into(emptySet()),
+      userModes = data["userModes"].into(emptySet()),
+    )
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/MessageSerializer.kt

@@ -32,7 +32,11 @@ import java.nio.ByteBuffer
 object MessageSerializer : PrimitiveSerializer<Message> {
   override val javaType: Class<out Message> = Message::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: Message, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: Message,
+    featureSet: FeatureSet,
+  ) {
     MsgIdSerializer.serialize(buffer, data.messageId, featureSet)
     if (featureSet.hasFeature(QuasselFeature.LongTime)) {
       LongSerializer.serialize(buffer, data.time.toEpochMilli(), featureSet)
@@ -53,26 +57,44 @@ object MessageSerializer : PrimitiveSerializer<Message> {
     StringSerializerUtf8.serialize(buffer, data.content, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): Message {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): Message {
     return Message(
       messageId = MsgIdSerializer.deserialize(buffer, featureSet),
-      time = if (featureSet.hasFeature(QuasselFeature.LongTime))
+      time =
+        if (featureSet.hasFeature(QuasselFeature.LongTime)) {
           Instant.ofEpochMilli(LongSerializer.deserialize(buffer, featureSet))
-      else
-        Instant.ofEpochSecond(IntSerializer.deserialize(buffer, featureSet).toLong()),
+        } else {
+          Instant.ofEpochSecond(IntSerializer.deserialize(buffer, featureSet).toLong())
+        },
       type = MessageType.of(UIntSerializer.deserialize(buffer, featureSet)),
-      flag = MessageFlag.of(
-        UByteSerializer.deserialize(buffer, featureSet).toUInt()
+      flag =
+        MessageFlag.of(
+          UByteSerializer.deserialize(buffer, featureSet).toUInt(),
         ),
       bufferInfo = BufferInfoSerializer.deserialize(buffer, featureSet),
       sender = StringSerializerUtf8.deserialize(buffer, featureSet) ?: "",
-      senderPrefixes = if (featureSet.hasFeature(QuasselFeature.SenderPrefixes))
-        StringSerializerUtf8.deserialize(buffer, featureSet) ?: "" else "",
-      realName = if (featureSet.hasFeature(QuasselFeature.RichMessages))
-        StringSerializerUtf8.deserialize(buffer, featureSet) ?: "" else "",
-      avatarUrl = if (featureSet.hasFeature(QuasselFeature.RichMessages))
-        StringSerializerUtf8.deserialize(buffer, featureSet) ?: "" else "",
-      content = StringSerializerUtf8.deserialize(buffer, featureSet) ?: ""
+      senderPrefixes =
+        if (featureSet.hasFeature(QuasselFeature.SenderPrefixes)) {
+          StringSerializerUtf8.deserialize(buffer, featureSet) ?: ""
+        } else {
+          ""
+        },
+      realName =
+        if (featureSet.hasFeature(QuasselFeature.RichMessages)) {
+          StringSerializerUtf8.deserialize(buffer, featureSet) ?: ""
+        } else {
+          ""
+        },
+      avatarUrl =
+        if (featureSet.hasFeature(QuasselFeature.RichMessages)) {
+          StringSerializerUtf8.deserialize(buffer, featureSet) ?: ""
+        } else {
+          ""
+        },
+      content = StringSerializerUtf8.deserialize(buffer, featureSet) ?: "",
     )
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/MsgIdSerializer.kt

@@ -24,7 +24,11 @@ import java.nio.ByteBuffer
 object MsgIdSerializer : PrimitiveSerializer<MsgId> {
   override val javaType: Class<out MsgId> = MsgId::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: MsgId, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: MsgId,
+    featureSet: FeatureSet,
+  ) {
     if (featureSet.hasFeature(QuasselFeature.LongMessageId)) {
       LongSerializer.serialize(buffer, data.id, featureSet)
     } else {
@@ -32,7 +36,10 @@ object MsgIdSerializer : PrimitiveSerializer<MsgId> {
     }
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): MsgId {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): MsgId {
     return if (featureSet.hasFeature(QuasselFeature.LongMessageId)) {
       MsgId(LongSerializer.deserialize(buffer, featureSet))
     } else {

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/NetworkIdSerializer.kt

@@ -22,11 +22,18 @@ import java.nio.ByteBuffer
 object NetworkIdSerializer : PrimitiveSerializer<NetworkId> {
   override val javaType: Class<out NetworkId> = NetworkId::class.java
 
-  override fun serialize(buffer: ChainedByteBuffer, data: NetworkId, featureSet: FeatureSet) {
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: NetworkId,
+    featureSet: FeatureSet,
+  ) {
     IntSerializer.serialize(buffer, data.id, featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): NetworkId {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): NetworkId {
     return NetworkId(IntSerializer.deserialize(buffer, featureSet))
   }
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/NetworkInfoSerializer.kt

 /*
  * libquassel
- * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2024 Janne Mareike Koschinski
  *
  * This Source Code Form is subject to the terms of the Mozilla Public License,
  * v. 2.0. If a copy of the MPL was not distributed with this file, You can
@@ -14,7 +14,7 @@ import de.justjanne.libquassel.protocol.io.ChainedByteBuffer
 import de.justjanne.libquassel.protocol.models.QStringList
 import de.justjanne.libquassel.protocol.models.ids.IdentityId
 import de.justjanne.libquassel.protocol.models.ids.NetworkId
-import de.justjanne.libquassel.protocol.models.network.NetworkInfo
+import de.justjanne.libquassel.protocol.models.network.NetworkInfoDto
 import de.justjanne.libquassel.protocol.models.network.NetworkServer
 import de.justjanne.libquassel.protocol.models.types.QtType
 import de.justjanne.libquassel.protocol.models.types.QuasselType
@@ -26,17 +26,26 @@ import de.justjanne.libquassel.protocol.variant.into
 import de.justjanne.libquassel.protocol.variant.qVariant
 import java.nio.ByteBuffer
 
-object NetworkInfoSerializer : PrimitiveSerializer<NetworkInfo> {
-  override val javaType: Class<NetworkInfo> = NetworkInfo::class.java
-  override fun serialize(buffer: ChainedByteBuffer, data: NetworkInfo, featureSet: FeatureSet) {
-    QVariantMapSerializer.serialize(buffer, serializeMap(data), featureSet)
+object NetworkInfoSerializer : PrimitiveSerializer<NetworkInfoDto> {
+  override val javaType: Class<NetworkInfoDto> = NetworkInfoDto::class.java
+
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: NetworkInfoDto,
+    featureSet: FeatureSet,
+  ) {
+    QVariantMapSerializer.serialize(buffer, toMap(data), featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): NetworkInfo {
-    return deserializeMap(QVariantMapSerializer.deserialize(buffer, featureSet))
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): NetworkInfoDto {
+    return fromMap(QVariantMapSerializer.deserialize(buffer, featureSet))
   }
 
-  fun serializeMap(data: NetworkInfo): QVariantMap = mapOf(
+  private fun toMap(data: NetworkInfoDto): QVariantMap =
+    mapOf(
       "NetworkId" to qVariant(data.networkId, QuasselType.NetworkId),
       "NetworkName" to qVariant(data.networkName, QtType.QString),
       "Identity" to qVariant(data.identity, QuasselType.IdentityId),
@@ -61,10 +70,11 @@ object NetworkInfoSerializer : PrimitiveSerializer<NetworkInfo> {
       "UseCustomMessageRate" to qVariant(data.useCustomMessageRate, QtType.Bool),
       "MessageRateBurstSize" to qVariant(data.messageRateBurstSize, QtType.UInt),
       "MessageRateDelay" to qVariant(data.messageRateDelay, QtType.UInt),
-    "UnlimitedMessageRate" to qVariant(data.unlimitedMessageRate, QtType.Bool)
+      "UnlimitedMessageRate" to qVariant(data.unlimitedMessageRate, QtType.Bool),
     )
 
-  fun deserializeMap(data: QVariantMap) = NetworkInfo(
+  private fun fromMap(data: QVariantMap) =
+    NetworkInfoDto(
       networkId = data["NetworkId"].into(NetworkId(-1)),
       networkName = data["NetworkName"].into(""),
       identity = data["Identity"].into(IdentityId(-1)),
@@ -89,6 +99,6 @@ object NetworkInfoSerializer : PrimitiveSerializer<NetworkInfo> {
       useCustomMessageRate = data["UseCustomMessageRate"].into(false),
       messageRateBurstSize = data["MessageRateBurstSize"].into(0u),
       messageRateDelay = data["MessageRateDelay"].into(0u),
-    unlimitedMessageRate = data["UnlimitedMessageRate"].into(false)
+      unlimitedMessageRate = data["UnlimitedMessageRate"].into(false),
     )
 }

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/serializers/quassel/NetworkServerSerializer.kt

@@ -24,15 +24,24 @@ import java.nio.ByteBuffer
 
 object NetworkServerSerializer : PrimitiveSerializer<NetworkServer> {
   override val javaType: Class<NetworkServer> = NetworkServer::class.java
-  override fun serialize(buffer: ChainedByteBuffer, data: NetworkServer, featureSet: FeatureSet) {
+
+  override fun serialize(
+    buffer: ChainedByteBuffer,
+    data: NetworkServer,
+    featureSet: FeatureSet,
+  ) {
     QVariantMapSerializer.serialize(buffer, serializeMap(data), featureSet)
   }
 
-  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): NetworkServer {
+  override fun deserialize(
+    buffer: ByteBuffer,
+    featureSet: FeatureSet,
+  ): NetworkServer {
     return deserializeMap(QVariantMapSerializer.deserialize(buffer, featureSet))
   }
 
-  fun serializeMap(data: NetworkServer): QVariantMap = mapOf(
+  fun serializeMap(data: NetworkServer): QVariantMap =
+    mapOf(
       "Host" to qVariant(data.host, QtType.QString),
       "Port" to qVariant(data.port, QtType.UInt),
       "Password" to qVariant(data.password, QtType.QString),
@@ -44,10 +53,11 @@ object NetworkServerSerializer : PrimitiveSerializer<NetworkServer> {
       "ProxyHost" to qVariant(data.proxyHost, QtType.QString),
       "ProxyPort" to qVariant(data.proxyPort, QtType.UInt),
       "ProxyUser" to qVariant(data.proxyUser, QtType.QString),
-    "ProxyPass" to qVariant(data.proxyPass, QtType.QString)
+      "ProxyPass" to qVariant(data.proxyPass, QtType.QString),
     )
 
-  fun deserializeMap(data: QVariantMap) = NetworkServer(
+  fun deserializeMap(data: QVariantMap) =
+    NetworkServer(
       host = data["Host"].into(""),
       port = data["Port"].into(PortDefaults.PORT_PLAINTEXT.port),
       password = data["Password"].into(""),
@@ -55,11 +65,12 @@ object NetworkServerSerializer : PrimitiveSerializer<NetworkServer> {
       sslVerify = data["sslVerify"].into(false),
       sslVersion = data["sslVersion"].into(0),
       useProxy = data["UseProxy"].into(false),
-    proxyType = NetworkProxy.of(data["ProxyType"].into(NetworkProxy.Socks5Proxy.value))
+      proxyType =
+        NetworkProxy.of(data["ProxyType"].into(NetworkProxy.Socks5Proxy.value))
           ?: NetworkProxy.Socks5Proxy,
       proxyHost = data["ProxyHost"].into("localhost"),
       proxyPort = data["ProxyPort"].into(8080u),
       proxyUser = data["ProxyUser"].into(""),
-    proxyPass = data["ProxyPass"].into("")
+      proxyPass = data["ProxyPass"].into(""),
     )
 }