Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • api-redesign
  • main
  • 0.10.0
  • 0.10.1
  • 0.10.2
  • 0.7.0
  • 0.8.0
  • 0.8.1
  • 0.9.0
  • 0.9.1
  • 0.9.2
11 results

Target

Select target project
  • justJanne/libquassel
1 result
Select Git revision
  • api-redesign
  • main
  • 0.10.0
  • 0.10.1
  • 0.10.2
  • 0.7.0
  • 0.8.0
  • 0.8.1
  • 0.9.0
  • 0.9.1
  • 0.9.2
11 results
Show changes
Showing
with 459 additions and 177 deletions
......@@ -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
......
......@@ -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()
}
}
......@@ -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()
}
}
......@@ -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()
}
}
......@@ -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()
}
}
......@@ -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)
)
}
......@@ -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
}
......@@ -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))
}
}
......@@ -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,
)
}
}
......@@ -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))
}
......
......@@ -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))
}
......
......@@ -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
* 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
* 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
* 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()),
)
}
......@@ -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) ?: "",
)
}
}
......@@ -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 {
......
......@@ -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
* 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),
)
}
......@@ -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(""),
)
}