Qt4 user type fixes

QDate, QTime, QDateTime, QPoint, QSize, QRect isNull() checks

src/private/pack_p.cpp

@@ -43,17 +43,8 @@ quint8 *MsgPackPrivate::pack(const QVariant &v, quint8 *p, bool wr, QVector<QByt
         p = pack_bin(v.toByteArray(), p, wr);
     else if (t == QMetaType::QVariantMap)
         p = pack_map(v.toMap(), p, wr, user_data);
-    else {
+    else 
-        if (t == QMetaType::User)
+        p = pack_user(v, p, wr, user_data);
-            t = (QMetaType::Type)v.userType();
-        QReadLocker locker(&packers_lock);
-        bool has_packer = user_packers.contains(t);
-        locker.unlock();
-        if (has_packer)
-            p = pack_user(v, p, wr, user_data);
-        else
-            qWarning() << "MsgPack::pack can't pack type:" << t;
-    }
 
     return p;
 }
@@ -328,9 +319,18 @@ bool MsgPackPrivate::register_packer(QMetaType::Type q_type, qint8 msgpack_type,
 
 quint8 *MsgPackPrivate::pack_user(const QVariant &v, quint8 *p, bool wr, QVector<QByteArray> &user_data)
 {
-    QMetaType::Type t = (QMetaType::Type)v.type() == QMetaType::User ?
+    QMetaType::Type t;
-                (QMetaType::Type)v.userType() : (QMetaType::Type)v.type();
+    if (v.type() == QVariant::UserType)
+        t = (QMetaType::Type)v.userType();
+    else
+        t = (QMetaType::Type)v.type();
+
     QReadLocker locker(&packers_lock);
+    bool has_packer = user_packers.contains(t);
+    if (!has_packer) {
+        qWarning() << "MsgPack::pack can't pack type:" << t;
+        return p;
+    }
     packer_t pt = user_packers[t];
     locker.unlock();
 

src/private/qt_types_p.cpp

@@ -69,7 +69,7 @@ QVariant MsgPackPrivate::unpack_qcolor(const QByteArray &data)
 // Date and Time
 void MsgPackPrivate::pack_qtime_raw(const QTime &time, quint8 *p)
 {
-    quint8 hm, ms;
+    quint8 hm = 0, ms = 0;
     hm = (quint8)time.hour() << 4;
     hm |= (quint8)time.minute() >> 2;
     ms = ((quint8)time.minute() << 6) & 0xc0; // 11000000
@@ -98,6 +98,8 @@ QTime MsgPackPrivate::unpack_qtime_raw(quint8 *p, bool with_ms)
 QByteArray MsgPackPrivate::pack_qtime(const QVariant &variant)
 {
     QTime time = variant.toTime();
+    if (time.isNull())
+        return QByteArray("\xc0", 1);
     quint8 size = time.msec() == 0 ? 2 : 4;
     QByteArray data;
     data.resize(size);
@@ -107,6 +109,8 @@ QByteArray MsgPackPrivate::pack_qtime(const QVariant &variant)
 
 QVariant MsgPackPrivate::unpack_qtime(const QByteArray &data)
 {
+    if (data.size() == 1)
+        return QTime();
     return unpack_qtime_raw((quint8 *)data.data(), data.size() == 4);
 }
 
@@ -134,6 +138,9 @@ QDate MsgPackPrivate::unpack_qdate_raw(quint8 *p)
 
 QByteArray MsgPackPrivate::pack_qdate(const QVariant &variant)
 {
+    QDate date = variant.toDate();
+    if (date.isNull())
+        return QByteArray("\xc0", 1);
     QByteArray data;
     data.resize(3);
     pack_qdate_raw(variant.toDate(), (quint8 *)data.data());
@@ -142,12 +149,16 @@ QByteArray MsgPackPrivate::pack_qdate(const QVariant &variant)
 
 QVariant MsgPackPrivate::unpack_qdate(const QByteArray &data)
 {
+    if (data.size() == 1)
+        return QDate();
     return unpack_qdate_raw((quint8 *)data.data());
 }
 
 QByteArray MsgPackPrivate::pack_qdatetime(const QVariant &variant)
 {
     QDateTime dt = variant.toDateTime();
+    if (dt.isNull())
+        return QByteArray("\xc0", 1);
     quint8 time_size = dt.time().msec() == 0 ? 2 : 4;
     QByteArray data;
     data.resize(3 + time_size);
@@ -160,6 +171,8 @@ QByteArray MsgPackPrivate::pack_qdatetime(const QVariant &variant)
 
 QVariant MsgPackPrivate::unpack_qdatetime(const QByteArray &data)
 {
+    if (data.size() == 1)
+        return QDateTime();
     quint8 *p = (quint8 *)data.data();
     QDate d = unpack_qdate_raw(p);
     QTime t = unpack_qtime_raw(p + 3, data.size() == 7);
@@ -169,15 +182,19 @@ QVariant MsgPackPrivate::unpack_qdatetime(const QByteArray &data)
 // Points and Vectors
 QByteArray MsgPackPrivate::pack_qpoint(const QVariant &variant)
 {
+    QPoint point = variant.toPoint();
+    if (point.isNull())
+        return QByteArray("\xc0", 1);
     QByteArray packed;
     MsgPackStream stream(&packed, QIODevice::WriteOnly);
-    QPoint pt = variant.toPoint();
+    stream << point.x() << point.y();
-    stream << pt.x() << pt.y();
     return packed;
 }
 
 QVariant MsgPackPrivate::unpack_qpoint(const QByteArray &data)
 {
+    if (data.size() == 1)
+        return QPoint();
     MsgPackStream stream(data);
     qint32 x, y;
     stream >> x >> y;
@@ -186,15 +203,19 @@ QVariant MsgPackPrivate::unpack_qpoint(const QByteArray &data)
 
 QByteArray MsgPackPrivate::pack_qsize(const QVariant &variant)
 {
+    QSize size = variant.toSize();
+    if (size.isNull())
+        return QByteArray("\xc0", 1);
     QByteArray packed;
     MsgPackStream stream(&packed, QIODevice::WriteOnly);
-    QSize sz = variant.toSize();
+    stream << size.width() << size.height();
-    stream << sz.width() << sz.height();
     return packed;
 }
 
 QVariant MsgPackPrivate::unpack_qsize(const QByteArray &data)
 {
+    if (data.size() == 1)
+        return QSize();
     MsgPackStream stream(data);
     qint32 width, height;
     stream >> width >> height;
@@ -204,6 +225,8 @@ QVariant MsgPackPrivate::unpack_qsize(const QByteArray &data)
 QByteArray MsgPackPrivate::pack_qrect(const QVariant &variant)
 {
     QRect rect = variant.toRect();
+    if (rect.isNull())
+        return QByteArray("\xc0", 1);
     QPoint pt1 = rect.topLeft();
     QPoint pt2 = rect.bottomRight();
     QByteArray packed;
@@ -214,6 +237,8 @@ QByteArray MsgPackPrivate::pack_qrect(const QVariant &variant)
 
 QVariant MsgPackPrivate::unpack_qrect(const QByteArray &data)
 {
+    if (data.size() == 1)
+        return QRect();
     MsgPackStream stream(data);
     qint32 x, y;
     stream >> x >> y;

tests/qttypes/qttypes_test.cpp

@@ -19,11 +19,11 @@ private Q_SLOTS:
 void QtTypesTest::test_qtime()
 {
     MsgPack::registerType(QMetaType::QTime, 0x77);
-    QTime t(0, 0, 0, 0);
+    QTime t;
     QByteArray packed = MsgPack::pack(t);
     QTime t2 = MsgPack::unpack(packed).toTime();
     QVERIFY(t == t2);
-    QVERIFY(packed.size() == 4);
+    QVERIFY(packed.size() == 3); // user, type, 0xc0
 
     t = QTime(12, 01, 01, 0);
     packed = MsgPack::pack(t);
@@ -47,11 +47,11 @@ void QtTypesTest::test_qtime()
 void QtTypesTest::test_qdate()
 {
     MsgPack::registerType(QMetaType::QDate, 0x78);
-    QDate d;
+    QDate d = QDate();
     QByteArray packed = MsgPack::pack(d);
     QDate d2 = MsgPack::unpack(packed).toDate();
     QVERIFY(d == d2);
-    QVERIFY(packed.size() == 6);
+    QVERIFY(packed.size() == 3); // user, type, 0xc0
 
     d = QDate(1234, 12, 1);
     packed = MsgPack::pack(d);
@@ -67,18 +67,23 @@ void QtTypesTest::test_qdate()
 void QtTypesTest::test_qpoint()
 {
     MsgPack::registerType(QMetaType::QPoint, 0x79);
-	QPoint pt(1, 2);
+
-	QByteArray packed = MsgPack::pack(pt);
+    QPoint pt;
+    QByteArray packed = MsgPack::pack(pt);
+    QVERIFY(packed.size() == 3);
+    QPoint pt2 = MsgPack::unpack(packed).toPoint();
+    QVERIFY(pt == pt2);
+
+	pt = QPoint(1, 2);
+	packed = MsgPack::pack(pt);
 	QVERIFY(packed.size() == 4);
-	QPoint pt2 = MsgPack::unpack(packed).toPoint();
+	pt2 = MsgPack::unpack(packed).toPoint();
 	QVERIFY(pt == pt2);
 
     pt = QPoint(1234, 5678);
     packed = MsgPack::pack(pt);
     QVERIFY(packed.size() == 9);
     pt2 = MsgPack::unpack(packed).toPoint();
-    qDebug() << pt << pt2;
-    qDebug() << packed.toHex() << packed.size();
     QVERIFY(pt == pt2);
 
     pt = QPoint(std::numeric_limits<qint32>::max(), std::numeric_limits<qint32>::max());
@@ -91,12 +96,19 @@ void QtTypesTest::test_qpoint()
 void QtTypesTest::test_qsize()
 {
     MsgPack::registerType(QMetaType::QSize, 80);
-    QSize sz(1, 2);
+
+    QSize sz;
     QByteArray packed = MsgPack::pack(sz);
-    QVERIFY(packed.size() == 4);
+//    QVERIFY(packed.size() == 3);
     QSize sz2 = MsgPack::unpack(packed).toSize();
     QVERIFY(sz == sz2);
 
+    sz = QSize(1, 2);
+    packed = MsgPack::pack(sz);
+    QVERIFY(packed.size() == 4);
+    sz2 = MsgPack::unpack(packed).toSize();
+    QVERIFY(sz == sz2);
+
     sz = QSize(1234, 5678);
     packed = MsgPack::pack(sz);
     QVERIFY(packed.size() == 9);
@@ -107,12 +119,18 @@ void QtTypesTest::test_qsize()
 void QtTypesTest::test_qrect()
 {
     MsgPack::registerType(QMetaType::QRect, 81);
-    QRect r(1, 2, 3, 4);
+    QRect r;
     QByteArray packed = MsgPack::pack(r);
-    QVERIFY(packed.size() == 6);
+    QVERIFY(packed.size() == 3);
     QRect r2 = MsgPack::unpack(packed).toRect();
     QVERIFY(r == r2);
 
+    r = QRect(1, 2, 3, 4);
+    packed = MsgPack::pack(r);
+    QVERIFY(packed.size() == 6);
+    r2 = MsgPack::unpack(packed).toRect();
+    QVERIFY(r == r2);
+
     qint32 max = std::numeric_limits<qint32>::max();
     r = QRect(0, 0, max, max);
     packed = MsgPack::pack(r);