Implement RPC stubs for quassel

libquassel-annotations/src/main/kotlin/de/justjanne/libquassel/annotations/ProtocolSide.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.annotations
+
+enum class ProtocolSide {
+  CLIENT,
+  CORE
+}

libquassel-annotations/src/main/kotlin/de/justjanne/libquassel/annotations/SyncedCall.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.annotations
+
+@Retention(AnnotationRetention.SOURCE)
+annotation class SyncedCall(
+  val name: String = "",
+  val target: ProtocolSide
+)

libquassel-annotations/src/main/kotlin/de/justjanne/libquassel/annotations/SyncedData.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.annotations
+
+@Retention(AnnotationRetention.SOURCE)
+annotation class SyncedData(
+  val name: String
+)

libquassel-annotations/src/main/kotlin/de/justjanne/libquassel/annotations/SyncedObject.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.annotations
+
+@Retention(AnnotationRetention.SOURCE)
+annotation class SyncedObject(
+  val name: String
+)

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/Alias.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+data class Alias(
+  val name: String?,
+  val expansion: String?
+)

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/Command.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+data class Command(
+  val buffer: BufferInfo,
+  val message: String
+)

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/HighlightNickType.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+enum class HighlightNickType(
+  val value: UByte,
+) {
+  NoNick(0x00u),
+  CurrentNick(0x01u),
+  AllNicks(0x02u);
+
+  companion object {
+    private val values = enumValues<HighlightNickType>()
+      .associateBy(HighlightNickType::value)
+
+    /**
+     * Obtain from underlying representation
+     */
+    fun of(value: UByte): HighlightNickType? = values[value]
+  }
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/NetworkInfo.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+import de.justjanne.libquassel.protocol.models.ids.IdentityId
+import de.justjanne.libquassel.protocol.models.ids.NetworkId
+
+data class NetworkInfo(
+  var networkId: NetworkId = NetworkId(-1),
+  var networkName: String = "",
+  var identity: IdentityId = IdentityId(-1),
+  var useCustomEncodings: Boolean = false,
+  var codecForServer: String = "UTF_8",
+  var codecForEncoding: String = "UTF_8",
+  var codecForDecoding: String = "UTF_8",
+  var serverList: List<NetworkServer> = emptyList(),
+  var useRandomServer: Boolean = false,
+  var perform: List<String> = emptyList(),
+  var useAutoIdentify: Boolean = false,
+  var autoIdentifyService: String = "",
+  var autoIdentifyPassword: String = "",
+  var useSasl: Boolean = false,
+  var saslAccount: String = "",
+  var saslPassword: String = "",
+  var useAutoReconnect: Boolean = true,
+  var autoReconnectInterval: UInt = 0u,
+  var autoReconnectRetries: UShort = 0u,
+  var unlimitedReconnectRetries: Boolean = true,
+  var rejoinChannels: Boolean = true,
+  var useCustomMessageRate: Boolean = false,
+  var messageRateBurstSize: UInt = 0u,
+  var messageRateDelay: UInt = 0u,
+  var unlimitedMessageRate: Boolean = false
+)

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/NetworkProxy.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+enum class NetworkProxy(
+  val value: Int,
+) {
+  DefaultProxy(0),
+  Socks5Proxy(1),
+  NoProxy(2),
+  HttpProxy(3),
+  HttpCachingProxy(4),
+  FtpCachingProxy(5);
+
+  companion object {
+    private val values = enumValues<NetworkProxy>()
+      .associateBy(NetworkProxy::value)
+
+    /**
+     * Obtain from underlying representation
+     */
+    fun of(value: Int): NetworkProxy? = values[value]
+  }
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/NetworkServer.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+data class NetworkServer(
+  val host: String,
+  val port: UInt = 6667u,
+  val password: String = "",
+  val useSsl: Boolean = false,
+  val sslVerify: Boolean = true,
+  val sslVersion: Int = 0,
+  val useProxy: Boolean = false,
+  val proxyType: NetworkProxy = NetworkProxy.Socks5Proxy,
+  val proxyHost: String = "localhost",
+  val proxyPort: UInt = 8080u,
+  val proxyUser: String = "",
+  val proxyPass: String = "",
+)

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/PortDefaults.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+enum class PortDefaults(
+  val port: UInt
+) {
+  PORT_PLAINTEXT(6667u),
+  PORT_SSL(6697u)
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/TransferDirection.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+enum class TransferDirection(
+  val value: Int,
+) {
+  Send(0),
+  Receive(1);
+
+  companion object {
+    private val values = enumValues<TransferDirection>()
+      .associateBy(TransferDirection::value)
+
+    /**
+     * Obtain from underlying representation
+     */
+    fun of(value: Int): TransferDirection? = values[value]
+  }
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/TransferIdList.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+import java.util.UUID
+
+/**
+ * Simple alias for a generic TransferIdList type
+ */
+typealias TransferIdList = List<UUID>

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/TransferStatus.kt

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.models
+
+enum class TransferStatus(
+  val value: Int,
+) {
+  New(0),
+  Pending(1),
+  Connecting(2),
+  Transferring(3),
+  Paused(4),
+  Completed(5),
+  Failed(6),
+  Rejected(7);
+
+  companion object {
+    private val values = enumValues<TransferStatus>()
+      .associateBy(TransferStatus::value)
+
+    /**
+     * Obtain from underlying representation
+     */
+    fun of(value: Int): TransferStatus? = values[value]
+  }
+}

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/types/QtType.kt

@@ -33,6 +33,7 @@ import de.justjanne.libquassel.protocol.serializers.qt.UByteSerializer
 import de.justjanne.libquassel.protocol.serializers.qt.UIntSerializer
 import de.justjanne.libquassel.protocol.serializers.qt.ULongSerializer
 import de.justjanne.libquassel.protocol.serializers.qt.UShortSerializer
+import de.justjanne.libquassel.protocol.serializers.qt.UuidSerializer
 import de.justjanne.libquassel.protocol.serializers.qt.VoidSerializer
 
 /**
@@ -120,6 +121,12 @@ enum class QtType(
    */
   Double(6, DoubleSerializer),
 
+  /**
+   * 128-bit UUID
+   * See [java.util.UUID]
+   */
+  Uuid(30, UuidSerializer),
+
   /**
    * Date in the gregorian calender as julian date
    * See [org.threeten.bp.LocalDate]

libquassel-protocol/src/main/kotlin/de/justjanne/libquassel/protocol/models/types/QuasselType.kt

@@ -20,8 +20,13 @@ import de.justjanne.libquassel.protocol.serializers.quassel.IdentityIdSerializer
 import de.justjanne.libquassel.protocol.serializers.quassel.MessageSerializer
 import de.justjanne.libquassel.protocol.serializers.quassel.MsgIdSerializer
 import de.justjanne.libquassel.protocol.serializers.quassel.NetworkIdSerializer
+import de.justjanne.libquassel.protocol.serializers.quassel.NetworkInfoSerializer
+import de.justjanne.libquassel.protocol.serializers.quassel.NetworkServerSerializer
 import de.justjanne.libquassel.protocol.serializers.quassel.PeerPtrSerializer
 import de.justjanne.libquassel.protocol.serializers.quassel.QHostAddressSerializer
+import de.justjanne.libquassel.protocol.serializers.quassel.TransferDirectionSerializer
+import de.justjanne.libquassel.protocol.serializers.quassel.TransferIdListSerializer
+import de.justjanne.libquassel.protocol.serializers.quassel.TransferStatusSerializer
 
 /**
  * Supported quassel types for serialization
@@ -42,80 +47,95 @@ enum class QuasselType(
   val qtType: QtType = QtType.UserType
 ) {
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.BufferId]
+   * Type for [de.justjanne.libquassel.protocol.models.BufferId]
    */
   BufferId("BufferId", BufferIdSerializer),
 
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.BufferInfo]
+   * Type for [de.justjanne.libquassel.protocol.models.BufferInfo]
    */
   BufferInfo("BufferInfo", BufferInfoSerializer),
 
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.DccIpDetectionMode]
+   * Type for [de.justjanne.libquassel.protocol.models.DccIpDetectionMode]
    */
   DccConfigIpDetectionMode("DccConfig::IpDetectionMode", DccIpDetectionModeSerializer),
 
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.DccPortSelectionMode]
+   * Type for [de.justjanne.libquassel.protocol.models.DccPortSelectionMode]
    */
   DccConfigPortSelectionMode("DccConfig::PortSelectionMode", DccPortSelectionModeSerializer),
 
   /**
    * Type for IrcUser objects
-   * Serialized as [QVariantMap]
+   * Serialized as [de.justjanne.libquassel.protocol.variant.QVariantMap]
    */
   IrcUser("IrcUser"),
 
   /**
    * Type for IrcChannel objects
-   * Serialized as [QVariantMap]
+   * Serialized as [de.justjanne.libquassel.protocol.variant.QVariantMap]
    */
   IrcChannel("IrcChannel"),
 
   /**
    * Type for Identity objects
-   * Serialized as [QVariantMap]
+   * Serialized as [de.justjanne.libquassel.protocol.variant.QVariantMap]
    */
   Identity("Identity"),
 
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.IdentityId]
+   * Type for [de.justjanne.libquassel.protocol.models.IdentityId]
    */
   IdentityId("IdentityId", IdentityIdSerializer),
 
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.Message]
+   * Type for [de.justjanne.libquassel.protocol.models.Message]
    */
   Message("Message", MessageSerializer),
 
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.MsgId]
+   * Type for [de.justjanne.libquassel.protocol.models.MsgId]
    */
   MsgId("MsgId", MsgIdSerializer),
 
   /**
-   * Type for [de.justjanne.libquassel.protocol.types.NetworkId]
+   * Type for [de.justjanne.libquassel.protocol.models.NetworkId]
    */
   NetworkId("NetworkId", NetworkIdSerializer),
 
   /**
    * Type for NetworkInfo objects
-   * Serialized as [QVariantMap]
+   * Serialized as [de.justjanne.libquassel.protocol.variant.QVariantMap]
    */
-  NetworkInfo("NetworkInfo"),
+  NetworkInfo("NetworkInfo", NetworkInfoSerializer),
 
   /**
    * Type for NetworkServer objects
-   * Serialized as [QVariantMap]
+   * Serialized as [de.justjanne.libquassel.protocol.variant.QVariantMap]
    */
-  NetworkServer("Network::Server"),
+  NetworkServer("Network::Server", NetworkServerSerializer),
 
   /**
    * Type for [java.net.InetAddress]
    */
   QHostAddress("QHostAddress", QHostAddressSerializer),
 
+  /**
+   * Type for [de.justjanne.libquassel.protocol.models.TransferDirection]
+   */
+  TransferDirection("Transfer::Direction", TransferDirectionSerializer),
+
+  /**
+   * Type for [de.justjanne.libquassel.protocol.models.TransferIdList]
+   */
+  TransferIdList("Transfer::TransferIdList", TransferIdListSerializer),
+
+  /**
+   * Type for [de.justjanne.libquassel.protocol.models.TransferStatus]
+   */
+  TransferStatus("Transfer::Status", TransferStatusSerializer),
+
   /**
    * Serialization type for PeerPtr.
    *

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

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package de.justjanne.libquassel.protocol.serializers.qt
+
+import de.justjanne.libquassel.protocol.features.FeatureSet
+import de.justjanne.libquassel.protocol.io.ChainedByteBuffer
+import de.justjanne.libquassel.protocol.serializers.PrimitiveSerializer
+import java.nio.ByteBuffer
+import java.util.UUID
+
+/**
+ * Serializer for [UUID]
+ */
+object UuidSerializer : PrimitiveSerializer<UUID> {
+  override val javaType: Class<UUID> = UUID::class.java
+
+  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(
+    LongSerializer.deserialize(buffer, featureSet),
+    LongSerializer.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) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+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.NetworkInfo
+import de.justjanne.libquassel.protocol.models.NetworkServer
+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.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.serializers.qt.StringSerializerUtf8
+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
+
+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)
+  }
+
+  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): NetworkInfo {
+    return deserializeMap(QVariantMapSerializer.deserialize(buffer, featureSet))
+  }
+
+  fun serializeMap(data: NetworkInfo): QVariantMap = mapOf(
+    "NetworkId" to qVariant(data.networkId, QuasselType.NetworkId),
+    "NetworkName" to qVariant(data.networkName, QtType.QString),
+    "Identity" to qVariant(data.identity, QuasselType.IdentityId),
+    "UseCustomEncodings" to qVariant(data.useCustomEncodings, QtType.Bool),
+    "CodecForServer" to qVariant(StringSerializerUtf8.serializeRaw(data.codecForServer), QtType.QByteArray),
+    "CodecForEncoding" to qVariant(StringSerializerUtf8.serializeRaw(data.codecForEncoding), QtType.QByteArray),
+    "CodecForDecoding" to qVariant(StringSerializerUtf8.serializeRaw(data.codecForDecoding), QtType.QByteArray),
+    "ServerList" to qVariant(data.serverList, QtType.QVariantList),
+    "UseRandomServer" to qVariant(data.useRandomServer, QtType.Bool),
+    "Perform" to qVariant(data.perform, QtType.QStringList),
+    "UseAutoIdentify" to qVariant(data.useAutoIdentify, QtType.Bool),
+    "AutoIdentifyService" to qVariant(data.autoIdentifyService, QtType.QString),
+    "AutoIdentifyPassword" to qVariant(data.autoIdentifyPassword, QtType.QString),
+    "UseSasl" to qVariant(data.useSasl, QtType.Bool),
+    "SaslAccount" to qVariant(data.saslAccount, QtType.QString),
+    "SaslPassword" to qVariant(data.saslPassword, QtType.QString),
+    "UseAutoReconnect" to qVariant(data.useAutoReconnect, QtType.Bool),
+    "AutoReconnectInterval" to qVariant(data.autoReconnectInterval, QtType.UInt),
+    "AutoReconnectRetries" to qVariant(data.autoReconnectRetries, QtType.UShort),
+    "UnlimitedReconnectRetries" to qVariant(data.unlimitedReconnectRetries, QtType.Bool),
+    "RejoinChannels" to qVariant(data.rejoinChannels, QtType.Bool),
+    "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)
+  )
+
+  fun deserializeMap(data: QVariantMap) = NetworkInfo(
+    networkId = data["NetworkId"].into(NetworkId(-1)),
+    networkName = data["NetworkName"].into(""),
+    identity = data["Identity"].into(IdentityId(-1)),
+    useCustomEncodings = data["UseCustomEncodings"].into(false),
+    codecForServer = data["CodecForServer"].into("UTF_8"),
+    codecForEncoding = data["CodecForEncoding"].into("UTF_8"),
+    codecForDecoding = data["CodecForDecoding"].into("UTF_8"),
+    serverList = data["ServerList"].into<List<NetworkServer>>().orEmpty(),
+    useRandomServer = data["UseRandomServer"].into(false),
+    perform = data["Perform"].into<QStringList>().orEmpty().filterNotNull(),
+    useAutoIdentify = data["UseAutoIdentify"].into(false),
+    autoIdentifyService = data["AutoIdentifyService"].into(""),
+    autoIdentifyPassword = data["AutoIdentifyPassword"].into(""),
+    useSasl = data["UseSasl"].into(false),
+    saslAccount = data["SaslAccount"].into(""),
+    saslPassword = data["SaslPassword"].into(""),
+    useAutoReconnect = data["UseAutoReconnect"].into(true),
+    autoReconnectInterval = data["AutoReconnectInterval"].into(0u),
+    autoReconnectRetries = data["AutoReconnectRetries"].into(0u),
+    unlimitedReconnectRetries = data["UnlimitedReconnectRetries"].into(true),
+    rejoinChannels = data["RejoinChannels"].into(true),
+    useCustomMessageRate = data["UseCustomMessageRate"].into(false),
+    messageRateBurstSize = data["MessageRateBurstSize"].into(0u),
+    messageRateDelay = data["MessageRateDelay"].into(0u),
+    unlimitedMessageRate = data["UnlimitedMessageRate"].into(false)
+  )
+}

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

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+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.NetworkProxy
+import de.justjanne.libquassel.protocol.models.NetworkServer
+import de.justjanne.libquassel.protocol.models.PortDefaults
+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.variant.QVariantMap
+import de.justjanne.libquassel.protocol.variant.into
+import de.justjanne.libquassel.protocol.variant.qVariant
+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) {
+    QVariantMapSerializer.serialize(buffer, serializeMap(data), featureSet)
+  }
+
+  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet): NetworkServer {
+    return deserializeMap(QVariantMapSerializer.deserialize(buffer, featureSet))
+  }
+
+  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),
+    "UseSSL" to qVariant(data.useSsl, QtType.Bool),
+    "sslVerify" to qVariant(data.sslVerify, QtType.Bool),
+    "sslVersion" to qVariant(data.sslVersion, QtType.Int),
+    "UseProxy" to qVariant(data.useProxy, QtType.Bool),
+    "ProxyType" to qVariant(data.proxyType, QtType.Int),
+    "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)
+  )
+
+  fun deserializeMap(data: QVariantMap) = NetworkServer(
+    host = data["Host"].into(""),
+    port = data["Port"].into(PortDefaults.PORT_PLAINTEXT.port),
+    password = data["Password"].into(""),
+    useSsl = data["UseSSL"].into(false),
+    sslVerify = data["sslVerify"].into(false),
+    sslVersion = data["sslVersion"].into(0),
+    useProxy = data["UseProxy"].into(false),
+    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("")
+  )
+}

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

+/*
+ * libquassel
+ * Copyright (c) 2021 Janne Mareike Koschinski
+ * Copyright (c) 2021 The Quassel Project
+ *
+ * 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
+ * obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+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.TransferDirection
+import de.justjanne.libquassel.protocol.serializers.PrimitiveSerializer
+import de.justjanne.libquassel.protocol.serializers.qt.IntSerializer
+import java.nio.ByteBuffer
+
+/**
+ * Serializer for [TransferDirection]
+ */
+object TransferDirectionSerializer : PrimitiveSerializer<TransferDirection?> {
+  override val javaType: Class<out TransferDirection?> = TransferDirection::class.java
+
+  override fun serialize(buffer: ChainedByteBuffer, data: TransferDirection?, featureSet: FeatureSet) {
+    IntSerializer.serialize(buffer, data?.value ?: 0, featureSet)
+  }
+
+  override fun deserialize(buffer: ByteBuffer, featureSet: FeatureSet) = TransferDirection.of(
+    IntSerializer.deserialize(buffer, featureSet)
+  )
+}