modernize: Reformat ALL the source... again!

[quassel.git] / src / common / serializers / serializers.cpp

diff --git a/src/common/serializers/serializers.cpp b/src/common/serializers/serializers.cpp
index 5050940..21ca92f 100644 (file)
--- a/src/common/serializers/serializers.cpp
+++ b/src/common/serializers/serializers.cpp
@@ -20,7 +20,7 @@
 
 #include "serializers.h"
 
-bool checkStreamValid(QDataStream &stream)
+bool checkStreamValid(QDataStream& stream)
 {
     if (stream.status() != QDataStream::Ok) {
         qWarning() << "Peer sent corrupt data";
@@ -30,7 +30,7 @@ bool checkStreamValid(QDataStream &stream)
     return true;
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QVariantList &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QVariantList& data)
 {
     uint32_t size;
     if (!deserialize(stream, features, size))
@@ -48,7 +48,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QVariantMap &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QVariantMap& data)
 {
     uint32_t size;
     if (!deserialize(stream, features, size))
@@ -69,7 +69,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QVariant &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QVariant& data)
 {
     Types::VariantType type;
     int8_t isNull;
@@ -85,240 +85,241 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
             name.chop(1);
         if (!deserialize(stream, features, data, Types::fromName(name)))
             return false;
-    } else {
+    }
+    else {
         if (!deserialize(stream, features, data, type))
             return false;
     }
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QVariant &data, Types::VariantType type)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QVariant& data, Types::VariantType type)
 {
     switch (type) {
-        case Types::VariantType::Void: {
-            return true;
-        }
-        case Types::VariantType::Bool: {
-            bool content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::Int: {
-            int32_t content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::UInt: {
-            uint32_t content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QChar: {
-            QChar content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QVariantMap: {
-            QVariantMap content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QVariantList: {
-            QVariantList content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QString: {
-            QString content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QStringList: {
-            QStringList content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QByteArray: {
-            QByteArray content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QDate: {
-            QDate content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QTime: {
-            QTime content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QDateTime: {
-            QDateTime content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::Long: {
-            qlonglong content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::Short: {
-            int16_t content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::Char: {
-            int8_t content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::ULong: {
-            qulonglong content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::UShort: {
-            uint16_t content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::UChar: {
-            uint8_t content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        case Types::VariantType::QVariant: {
-            QVariant content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = QVariant(content);
-            return true;
-        }
-        default: {
-            qWarning() << "Usertype should have been caught earlier already";
+    case Types::VariantType::Void: {
+        return true;
+    }
+    case Types::VariantType::Bool: {
+        bool content;
+        if (!deserialize(stream, features, content))
             return false;
-        }
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::Int: {
+        int32_t content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::UInt: {
+        uint32_t content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QChar: {
+        QChar content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QVariantMap: {
+        QVariantMap content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QVariantList: {
+        QVariantList content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QString: {
+        QString content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QStringList: {
+        QStringList content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QByteArray: {
+        QByteArray content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QDate: {
+        QDate content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QTime: {
+        QTime content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QDateTime: {
+        QDateTime content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::Long: {
+        qlonglong content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::Short: {
+        int16_t content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::Char: {
+        int8_t content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::ULong: {
+        qulonglong content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::UShort: {
+        uint16_t content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::UChar: {
+        uint8_t content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    case Types::VariantType::QVariant: {
+        QVariant content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = QVariant(content);
+        return true;
+    }
+    default: {
+        qWarning() << "Usertype should have been caught earlier already";
+        return false;
+    }
     }
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QVariant &data, Types::QuasselType type)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QVariant& data, Types::QuasselType type)
 {
     switch (type) {
-        case Types::QuasselType::BufferId: {
-            BufferId content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::BufferInfo: {
-            BufferInfo content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::Identity: {
-            Identity content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::IdentityId: {
-            IdentityId content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::Message: {
-            Message content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::MsgId: {
-            MsgId content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::NetworkId: {
-            NetworkId content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::NetworkInfo: {
-            NetworkInfo content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::Network_Server: {
-            Network::Server content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        case Types::QuasselType::PeerPtr: {
-            PeerPtr content;
-            if (!deserialize(stream, features, content))
-                return false;
-            data = qVariantFromValue(content);
-            return true;
-        }
-        default: {
-            qWarning() << "Invalid QType";
+    case Types::QuasselType::BufferId: {
+        BufferId content;
+        if (!deserialize(stream, features, content))
             return false;
-        }
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::BufferInfo: {
+        BufferInfo content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::Identity: {
+        Identity content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::IdentityId: {
+        IdentityId content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::Message: {
+        Message content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::MsgId: {
+        MsgId content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::NetworkId: {
+        NetworkId content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::NetworkInfo: {
+        NetworkInfo content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::Network_Server: {
+        Network::Server content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    case Types::QuasselType::PeerPtr: {
+        PeerPtr content;
+        if (!deserialize(stream, features, content))
+            return false;
+        data = qVariantFromValue(content);
+        return true;
+    }
+    default: {
+        qWarning() << "Invalid QType";
+        return false;
+    }
     }
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, Types::VariantType &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, Types::VariantType& data)
 {
     uint32_t raw;
     if (!deserialize(stream, features, raw))
@@ -327,7 +328,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QStringList &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QStringList& data)
 {
     uint32_t size;
     if (!deserialize(stream, features, size))
@@ -341,7 +342,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, Network::Server &server)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, Network::Server& server)
 {
     Q_UNUSED(features);
     QVariantMap serverMap;
@@ -362,7 +363,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, Identity &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, Identity& data)
 {
     Q_UNUSED(features);
     QVariantMap raw;
@@ -372,7 +373,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, NetworkInfo &info)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, NetworkInfo& info)
 {
     Q_UNUSED(features);
     QVariantMap i;
@@ -406,14 +407,14 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, PeerPtr &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, PeerPtr& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QByteArray &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QByteArray& data)
 {
     Q_UNUSED(features);
     data.clear();
@@ -446,7 +447,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QString &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QString& data)
 {
     Q_UNUSED(features);
     uint32_t bytes = 0;
@@ -482,7 +483,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     while (allocated < length) {
         int blockSize = std::min(step, length - allocated);
         data.resize(allocated + blockSize);
-        if (stream.readRawData(reinterpret_cast<char *>(data.data()) + allocated * 2, blockSize * 2) != blockSize * 2) {
+        if (stream.readRawData(reinterpret_cast<char*>(data.data()) + allocated * 2, blockSize * 2) != blockSize * 2) {
             data.clear();
             qWarning() << "BufferUnderFlow while reading QString";
             return false;
@@ -490,7 +491,7 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
         allocated += blockSize;
     }
     if ((stream.byteOrder() == QDataStream::BigEndian) != (QSysInfo::ByteOrder == QSysInfo::BigEndian)) {
-        auto *rawData = reinterpret_cast<uint16_t *>(data.data());
+        auto* rawData = reinterpret_cast<uint16_t*>(data.data());
         while (length--) {
             *rawData = qbswap(*rawData);
             ++rawData;
@@ -499,133 +500,133 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QChar &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QChar& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QDate &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QDate& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QTime &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QTime& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, QDateTime &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, QDateTime& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, int32_t &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, int32_t& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, uint32_t &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, uint32_t& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, int16_t &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, int16_t& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, uint16_t &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, uint16_t& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, int8_t &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, int8_t& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, uint8_t &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, uint8_t& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, qlonglong &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, qlonglong& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, qulonglong &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, qulonglong& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, bool &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, bool& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, BufferInfo &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, BufferInfo& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, Message &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, Message& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, NetworkId &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, NetworkId& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, IdentityId &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, IdentityId& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, BufferId &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, BufferId& data)
 {
     Q_UNUSED(features);
     stream >> data;
     return checkStreamValid(stream);
 }
 
-bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &features, MsgId &data)
+bool Serializers::deserialize(QDataStream& stream, const Quassel::Features& features, MsgId& data)
 {
     Q_UNUSED(features);
     stream >> data;
@@ -635,71 +636,81 @@ bool Serializers::deserialize(QDataStream &stream, const Quassel::Features &feat
 Serializers::Types::VariantType Serializers::Types::variantType(Serializers::Types::QuasselType type)
 {
     switch (type) {
-        case QuasselType::BufferId:
-            return VariantType::UserType;
-        case QuasselType::BufferInfo:
-            return VariantType::UserType;
-        case QuasselType::Identity:
-            return VariantType::UserType;
-        case QuasselType::IdentityId:
-            return VariantType::UserType;
-        case QuasselType::Message:
-            return VariantType::UserType;
-        case QuasselType::MsgId:
-            return VariantType::UserType;
-        case QuasselType::NetworkId:
-            return VariantType::UserType;
-        case QuasselType::NetworkInfo:
-            return VariantType::UserType;
-        case QuasselType::Network_Server:
-            return VariantType::UserType;
-        case QuasselType::PeerPtr:
-            return VariantType::Long;
-        default:
-            return VariantType::UserType;
+    case QuasselType::BufferId:
+        return VariantType::UserType;
+    case QuasselType::BufferInfo:
+        return VariantType::UserType;
+    case QuasselType::Identity:
+        return VariantType::UserType;
+    case QuasselType::IdentityId:
+        return VariantType::UserType;
+    case QuasselType::Message:
+        return VariantType::UserType;
+    case QuasselType::MsgId:
+        return VariantType::UserType;
+    case QuasselType::NetworkId:
+        return VariantType::UserType;
+    case QuasselType::NetworkInfo:
+        return VariantType::UserType;
+    case QuasselType::Network_Server:
+        return VariantType::UserType;
+    case QuasselType::PeerPtr:
+        return VariantType::Long;
+    default:
+        return VariantType::UserType;
     }
 }
 
 QString Serializers::Types::toName(Serializers::Types::QuasselType type)
 {
     switch (type) {
-        case QuasselType::BufferId:
-            return QString("BufferId");
-        case QuasselType::BufferInfo:
-            return QString("BufferInfo");
-        case QuasselType::Identity:
-            return QString("Identity");
-        case QuasselType::IdentityId:
-            return QString("IdentityId");
-        case QuasselType::Message:
-            return QString("Message");
-        case QuasselType::MsgId:
-            return QString("MsgId");
-        case QuasselType::NetworkId:
-            return QString("NetworkId");
-        case QuasselType::NetworkInfo:
-            return QString("NetworkInfo");
-        case QuasselType::Network_Server:
-            return QString("Network::Server");
-        case QuasselType::PeerPtr:
-            return QString("PeerPtr");
-        default:
-            return QString("Invalid Type");
-    }
-}
-
-Serializers::Types::QuasselType Serializers::Types::fromName(::QByteArray &name)
-{
-    if (qstrcmp(name, "BufferId") == 0) return QuasselType::BufferId;
-    else if (qstrcmp(name, "BufferInfo") == 0) return QuasselType::BufferInfo;
-    else if (qstrcmp(name, "Identity") == 0) return QuasselType::Identity;
-    else if (qstrcmp(name, "IdentityId") == 0) return QuasselType::IdentityId;
-    else if (qstrcmp(name, "Message") == 0) return QuasselType::Message;
-    else if (qstrcmp(name, "MsgId") == 0) return QuasselType::MsgId;
-    else if (qstrcmp(name, "NetworkId") == 0) return QuasselType::NetworkId;
-    else if (qstrcmp(name, "NetworkInfo") == 0) return QuasselType::NetworkInfo;
-    else if (qstrcmp(name, "Network::Server") == 0) return QuasselType::Network_Server;
-    else if (qstrcmp(name, "PeerPtr") == 0) return QuasselType::PeerPtr;
+    case QuasselType::BufferId:
+        return QString("BufferId");
+    case QuasselType::BufferInfo:
+        return QString("BufferInfo");
+    case QuasselType::Identity:
+        return QString("Identity");
+    case QuasselType::IdentityId:
+        return QString("IdentityId");
+    case QuasselType::Message:
+        return QString("Message");
+    case QuasselType::MsgId:
+        return QString("MsgId");
+    case QuasselType::NetworkId:
+        return QString("NetworkId");
+    case QuasselType::NetworkInfo:
+        return QString("NetworkInfo");
+    case QuasselType::Network_Server:
+        return QString("Network::Server");
+    case QuasselType::PeerPtr:
+        return QString("PeerPtr");
+    default:
+        return QString("Invalid Type");
+    }
+}
+
+Serializers::Types::QuasselType Serializers::Types::fromName(::QByteArray& name)
+{
+    if (qstrcmp(name, "BufferId") == 0)
+        return QuasselType::BufferId;
+    else if (qstrcmp(name, "BufferInfo") == 0)
+        return QuasselType::BufferInfo;
+    else if (qstrcmp(name, "Identity") == 0)
+        return QuasselType::Identity;
+    else if (qstrcmp(name, "IdentityId") == 0)
+        return QuasselType::IdentityId;
+    else if (qstrcmp(name, "Message") == 0)
+        return QuasselType::Message;
+    else if (qstrcmp(name, "MsgId") == 0)
+        return QuasselType::MsgId;
+    else if (qstrcmp(name, "NetworkId") == 0)
+        return QuasselType::NetworkId;
+    else if (qstrcmp(name, "NetworkInfo") == 0)
+        return QuasselType::NetworkInfo;
+    else if (qstrcmp(name, "Network::Server") == 0)
+        return QuasselType::Network_Server;
+    else if (qstrcmp(name, "PeerPtr") == 0)
+        return QuasselType::PeerPtr;
     else {
         qWarning() << "Type name is not valid: " << name;
         return QuasselType::Invalid;