user type packing implemented

.gitignore

@@ -0,0 +1 @@
+*.pro.user

main.cpp

@@ -1,18 +1,19 @@
 #include <QCoreApplication>
 #include <msgpack.h>
 #include <QDebug>
+#include <QDataStream>
+#include <QPoint>
 
-#include <vector>
-
-//int is_big_endian(void)
-//{
-//    union {
-//        quint32 i;
-//        char c[4];
-//    } bint = {0x01020304};
-
-//    return bint.c[0] == 1;
-//}
+quint32 packQPoint(const QVariant &variant, QByteArray &data, bool write)
+{
+    if (write) {
+        data.resize(8);
+        QDataStream out(&data, QIODevice::WriteOnly);
+        out.setVersion(QDataStream::Qt_5_3);
+        out << variant.toPoint();
+    }
+    return 8;
+}
 
 int main(int argc, char *argv[])
 {
@@ -20,19 +21,12 @@ int main(int argc, char *argv[])
     Q_UNUSED(argv)
     //QCoreApplication a(argc, argv);
 
-//    qDebug() << "MsgPack";
-//    qDebug() << MsgPack::deserialize(QByteArray::fromHex("dc 00 33 c2 c3 c0 00 00 00 00 00 00 00 00 00 ff ff ff ff ff 7f 7f cc ff cd ff ff ce ff ff ff ff e0 e0 d1 ff 80 d2 ff ff 80 00 d3 ff ff ff ff 80 00 00 00 00 00 01 ff a1 61 a1 61 a1 61 a0 a0 a0 91 00 91 00 91 00 90 90 90 80 80 80 81 a1 61 61 81 a1 61 61 81 a1 61 61 91 90 91 91 a1 61"));
-
-
+    MsgPack::registerPacker(QMetaType::QPoint, 7, packQPoint);
 
     QVariantList l;
-    QVariantMap map;
-    map["key"] = "val";
-    map["key2"] = 123;
-    map["key3"] = 1.2;
-    l << map;
-    qDebug() << l[0].type();
-    QByteArray arr = MsgPack::pack(map);
+
+    l << QPoint(1, 2);
+    QByteArray arr = MsgPack::pack(l);
     qDebug() << arr.toBase64();
 
 

msgpack.cpp

@@ -26,3 +26,9 @@ QByteArray MsgPack::pack(const QVariant &variant)
 
     return arr;
 }
+
+
+bool MsgPack::registerPacker(QMetaType::Type qType, qint8 msgpackType, MsgPack::pack_user_f packer)
+{
+    return MsgPackPrivate::register_packer(qType, msgpackType, packer);
+}

msgpack_common.h

@@ -4,7 +4,7 @@
 #include <QVariant>
 
 namespace MsgPack {
-typedef quint8 * (pack_user_f)(const QVariant &t, quint8 *p, bool wr);
+typedef quint32 (*pack_user_f)(const QVariant &variant, QByteArray &data, bool write);
 }
 
 #endif // COMMON_H

private/pack_p.cpp

@@ -1,5 +1,8 @@
 #include "pack_p.h"
 #include "private/sysdep.h"
+#include <QDebug>
+
+QHash<QMetaType::Type, MsgPackPrivate::packer_t> MsgPackPrivate::user_packers;
 
 quint8 *MsgPackPrivate::pack(const QVariant &v, quint8 *p, bool wr)
 {
@@ -24,6 +27,12 @@ quint8 *MsgPackPrivate::pack(const QVariant &v, quint8 *p, bool wr)
         p = pack_array(v.toByteArray(), p, wr);
     else if (t == QMetaType::QVariantMap)
         p = pack_map(v.toMap(), p, wr);
+    else {
+        if (user_packers.contains(t))
+            p = pack_user(v, p, wr);
+        else
+            qWarning() << "MsgPack::pack can't pack type:" << t;
+    }
 
     return p;
 }
@@ -233,3 +242,60 @@ quint8 *MsgPackPrivate::pack_map(const QVariantMap &map, quint8 *p, bool wr)
     }
     return p;
 }
+
+
+bool MsgPackPrivate::register_packer(QMetaType::Type q_type, qint8 msgpack_type, MsgPack::pack_user_f packer)
+{
+    if (user_packers.contains(q_type))
+        return false;
+    packer_t p;
+    p.packer = packer;
+    p.type = msgpack_type;
+    user_packers.insert(q_type, p);
+    return true;
+}
+
+quint8 *MsgPackPrivate::pack_user(const QVariant &v, quint8 *p, bool wr)
+{
+    QMetaType::Type t = (QMetaType::Type)v.type() == QMetaType::User ?
+                (QMetaType::Type)v.userType() : (QMetaType::Type)v.type();
+    QByteArray data;
+    packer_t pt = user_packers[t];
+    quint32 len = pt.packer(v, data, wr);
+    if (len == 1) {
+        if (wr) *p = 0xd4;
+        p++;
+    } else if (len == 2) {
+        if (wr) *p = 0xd5;
+        p++;
+    } else if (len == 4) {
+        if (wr) *p = 0xd6;
+        p++;
+    } else if (len == 8) {
+        if (wr) *p = 0xd7;
+        p++;
+    } else if (len == 16) {
+        if (wr) *p = 0xd8;
+        p++;
+    } else if (len <= 255) {
+        if (wr) *p = 0xc7;
+        p++;
+        if (wr) *p = len;
+        p++;
+    } else if (len <= 65535) {
+        if (wr) *p = 0xc8;
+        p++;
+        if (wr) _msgpack_store16(p, len);
+        p += 2;
+    } else {
+        if (wr) *p = 0xc9;
+        p++;
+        if (wr) _msgpack_store32(p, len);
+        p += 4;
+    }
+    if (wr) *p = pt.type;
+    p++;
+    if (wr)
+        memcpy(p, data.data(), len);
+    return p += len;
+}

private/pack_p.h

@@ -7,9 +7,12 @@ namespace MsgPackPrivate {
 /* if wr (write) == false, packer just moves pointer forward
  *
  */
-
-QHash<int, MsgPack::pack_user_f> user_packers;
-
+typedef struct {
+    MsgPack::pack_user_f packer;
+    qint8 type;
+} packer_t;
+bool register_packer(QMetaType::Type q_type, qint8 msgpack_type, MsgPack::pack_user_f packer);
+extern QHash<QMetaType::Type, packer_t> user_packers;
 
 quint8 * pack(const QVariant &v, quint8 *p, bool wr);
 
@@ -24,6 +27,7 @@ quint8 * pack_string(const QString &str, quint8 *p, bool wr);
 quint8 * pack_double(double i, quint8 *p, bool wr);
 quint8 * pack_array(const QByteArray &arr, quint8 *p, bool wr);
 quint8 * pack_map(const QVariantMap &map, quint8 *p, bool wr);
+quint8 * pack_user(const QVariant &v, quint8 *p, bool wr);
 
 
 

private/unpack_p.h

@@ -2,8 +2,6 @@
 #define MSGPACK_P_H
 #include <QVariant>
 
-
-
 namespace MsgPackPrivate
 {
 /* unpack functions:
@@ -26,7 +24,6 @@ quint32 unpack_uint8(quint8 *p);
 quint32 unpack_uint16(quint8 *p);
 quint32 unpack_uint32(quint8 *p);
 
-
 QVariant unpack_positive_fixint(quint8 *p, quint32 &sz);
 QVariant unpack_negative_fixint(quint8 *p, quint32 &sz);
 QVariant unpack_fixmap(quint8 *p, quint32 &sz);