From 39a26510dc22330054e04561ff73aabd1216c48c Mon Sep 17 00:00:00 2001 From: romixlab Date: Fri, 19 Sep 2014 23:26:24 +0400 Subject: [PATCH] user type unpacking implemented, unpack code reorganized --- main.cpp | 14 +- msgpack.cpp | 6 + msgpack.h | 1 + msgpack_common.h | 8 + private/pack_p.cpp | 8 +- private/unpack_p.cpp | 613 +++++++++++++++++++++---------------------- private/unpack_p.h | 103 ++++---- 7 files changed, 396 insertions(+), 357 deletions(-) diff --git a/main.cpp b/main.cpp index c16c6b0..32e49b2 100644 --- a/main.cpp +++ b/main.cpp @@ -15,6 +15,15 @@ quint32 packQPoint(const QVariant &variant, QByteArray &data, bool write) return 8; } +QVariant unpackQPoint(QByteArray &data) +{ + QDataStream in(&data, QIODevice::ReadOnly); + in.setVersion(QDataStream::Qt_5_3); + QPoint p; + in >> p; + return p; +} + int main(int argc, char *argv[]) { Q_UNUSED(argc) @@ -22,13 +31,16 @@ int main(int argc, char *argv[]) //QCoreApplication a(argc, argv); MsgPack::registerPacker(QMetaType::QPoint, 7, packQPoint); + MsgPack::registerUnpacker(7, unpackQPoint); QVariantList l; - l << QPoint(1, 2); + l << QPoint(12, 13); QByteArray arr = MsgPack::pack(l); qDebug() << arr.toBase64(); + qDebug() << MsgPack::unpack(arr); + return 0; //return a.exec(); diff --git a/msgpack.cpp b/msgpack.cpp index 3dd0da1..2c54923 100644 --- a/msgpack.cpp +++ b/msgpack.cpp @@ -32,3 +32,9 @@ bool MsgPack::registerPacker(QMetaType::Type qType, qint8 msgpackType, MsgPack:: { return MsgPackPrivate::register_packer(qType, msgpackType, packer); } + + +bool MsgPack::registerUnpacker(qint8 msgpackType, MsgPack::unpack_user_f unpacker) +{ + return MsgPackPrivate::register_unpacker(msgpackType, unpacker); +} diff --git a/msgpack.h b/msgpack.h index ee86f8a..34e13dd 100644 --- a/msgpack.h +++ b/msgpack.h @@ -7,6 +7,7 @@ namespace MsgPack { QVariant unpack(const QByteArray &data); + bool registerUnpacker(qint8 msgpackType, unpack_user_f unpacker); QByteArray pack(const QVariant &variant); bool registerPacker(QMetaType::Type qType, qint8 msgpackType, pack_user_f packer); diff --git a/msgpack_common.h b/msgpack_common.h index 9e04189..935f5ba 100644 --- a/msgpack_common.h +++ b/msgpack_common.h @@ -4,7 +4,15 @@ #include namespace MsgPack { +/** + * pack some variant to byte array data + * when write == false only calculates and returns size + * when write == true writes bytes to data, and returns the same size + * return type size + */ typedef quint32 (*pack_user_f)(const QVariant &variant, QByteArray &data, bool write); + +typedef QVariant (*unpack_user_f)(QByteArray &data); } #endif // COMMON_H diff --git a/private/pack_p.cpp b/private/pack_p.cpp index dc7d045..b81e7ca 100644 --- a/private/pack_p.cpp +++ b/private/pack_p.cpp @@ -246,8 +246,14 @@ quint8 *MsgPackPrivate::pack_map(const QVariantMap &map, quint8 *p, bool wr) bool MsgPackPrivate::register_packer(QMetaType::Type q_type, qint8 msgpack_type, MsgPack::pack_user_f packer) { - if (user_packers.contains(q_type)) + if (user_packers.contains(q_type)) { + qWarning() << "MsgPack::packer for qtype" << q_type << "already exist"; return false; + } + if (packer == 0) { + qWarning() << "MsgPack::packer for qtype" << q_type << "is invalid"; + return false; + } packer_t p; p.packer = packer; p.type = msgpack_type; diff --git a/private/unpack_p.cpp b/private/unpack_p.cpp index 6827850..4502f98 100644 --- a/private/unpack_p.cpp +++ b/private/unpack_p.cpp @@ -1,4 +1,5 @@ #include "unpack_p.h" +#include "sysdep.h" #include MsgPackPrivate::type_parser_f MsgPackPrivate::unpackers[32] = { @@ -16,15 +17,16 @@ MsgPackPrivate::type_parser_f MsgPackPrivate::unpackers[32] = { unpack_map16, unpack_map32 }; +QHash MsgPackPrivate::user_unpackers; + QVariant MsgPackPrivate::unpack(quint8 *p, quint8 *end) { QVariantList d; - quint32 typesz = 0; + QVariant v; while (p <= end) { - typesz = 0; - d.append(unpack_type(p, typesz)); - p += typesz; + p = unpack_type(v, p); + d.append(v); } if (p - end > 1) @@ -35,357 +37,352 @@ QVariant MsgPackPrivate::unpack(quint8 *p, quint8 *end) return d; } -QVariant MsgPackPrivate::unpack_type(quint8 *p, quint32 &sz) +quint8 *MsgPackPrivate::unpack_type(QVariant &v, quint8 *p) { - QVariant d; - if (*p <= 127) { // positive fixint 0x00 - 0x7f - d = unpack_positive_fixint(p, sz); + p = unpack_positive_fixint(v, p); } else if (*p >= 0xe0) { // negative fixint 0xe0 - 0xff - d = unpack_negative_fixint(p, sz); + p = unpack_negative_fixint(v, p); } else if (*p >= 0x80 && *p <= 0x8f) { // fixmap 1000xxxx 0x80 - 0x8f - d = unpack_fixmap(p, sz); + p = unpack_fixmap(v, p); } else if (*p >= 0x90 && *p <= 0x9f) { // fixarray 1001xxxx 0x90 - 0x9f - d = unpack_fixarray(p, sz); + p = unpack_fixarray(v, p); } else if (*p >= 0xa0 && *p <= 0xbf) { // fixstr 101xxxxx 0xa0 - 0xbf - d = unpack_fixstr(p, sz); + p = unpack_fixstr(v, p); } else { // all other types - d = (unpackers[*p - 0xc0])(p, sz); + p = (unpackers[*p - 0xc0])(v, p); } //qDebug() << "unpack type res:" << d << sz; - return d; + return p; } -QVariant MsgPackPrivate::unpack_positive_fixint(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_nil(QVariant &v, quint8 *p) { - sz += 1; - quint32 val = (quint32)*p; - return val; + Q_UNUSED(p) + Q_UNUSED(v) + return p + 1; } -QVariant MsgPackPrivate::unpack_negative_fixint(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_never_used(QVariant &v, quint8 *p) { - sz += 1; - quint8 val8 = (quint8)*p; - val8 &= ~((1 << 7) | (1 << 6) | (1 << 5)); - qint32 val = 0xffffffff; - val &= (0xffffffe0 | val8); - return val; + Q_UNUSED(p) + Q_UNUSED(v) + return p + 1; } -QVariant MsgPackPrivate::unpack_map_len(quint8 *p, quint32 &sz, quint32 len) +quint8 * MsgPackPrivate::unpack_false(QVariant &v, quint8 *p) { - quint32 elemsz = 0; - QMap map; - - for (quint32 i = 0; i < len; ++i) { - elemsz = 0; - QVariant key = unpack_type(p, elemsz); - p += elemsz; sz += elemsz; - elemsz = 0; - - QVariant val = unpack_type(p, elemsz); - p += elemsz; sz += elemsz; - map.insert(key.toString(), val); - } - return map; + Q_UNUSED(p) + v = false; + return p + 1; } -QVariant MsgPackPrivate::unpack_fixmap(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_true(QVariant &v, quint8 *p) { - sz += 1; - quint32 len = (*p++) & 0x0f; // 0b00001111 - return unpack_map_len(p, sz ,len); + Q_UNUSED(p) + v = true; + return p + 1; } -QVariant MsgPackPrivate::unpack_array_len(quint8 *p, quint32 &sz, quint32 len) +quint8 * MsgPackPrivate::unpack_positive_fixint(QVariant &v, quint8 *p) +{ + v = (quint32)*p; + return p + 1; +} + +quint8 * MsgPackPrivate::unpack_negative_fixint(QVariant &v, quint8 *p) +{ + v = (qint8)*p; + return p + 1; +} + +quint8 * MsgPackPrivate::unpack_uint8(QVariant &v, quint8 *p) +{ + v = (quint8)*(++p); + return p++; +} + +quint8 * MsgPackPrivate::unpack_uint16(QVariant &v, quint8 *p) +{ + p++; + v = _msgpack_load16(quint16, p); + return p + 2; +} + +quint8 * MsgPackPrivate::unpack_uint32(QVariant &v, quint8 *p) +{ + p++; + v = _msgpack_load32(quint32, p); + return p + 4; +} + +quint8 * MsgPackPrivate::unpack_uint64(QVariant &v, quint8 *p) +{ + p++; + v = _msgpack_load64(quint64, p); + return p + 8; +} + +quint8 * MsgPackPrivate::unpack_int8(QVariant &v, quint8 *p) +{ + v = (qint8)*(++p); + return p + 1; +} + +quint8 * MsgPackPrivate::unpack_int16(QVariant &v, quint8 *p) +{ + p++; + v = _msgpack_load16(qint16, p); + return p + 2; +} + +quint8 * MsgPackPrivate::unpack_int32(QVariant &v, quint8 *p) +{ + p++; + v = _msgpack_load32(quint32, p); + return p + 4; +} + +quint8 * MsgPackPrivate::unpack_int64(QVariant &v, quint8 *p) +{ + p++; + v = _msgpack_load64(qint64, p); + return p + 8; +} + +quint8 * MsgPackPrivate::unpack_float32(QVariant &v, quint8 *p) +{ + float f; + quint8 *fp = (quint8 *)&f; + p++; +#ifdef __LITTLE_ENDIAN__ + for (int i = 0; i < 4; ++i) + *(fp + 3 - i) = *(p + i); +#else + for (int i = 0; i < 4; ++i) + *(fp + i) = *(p + i); +#endif + v = f; + return p + 4; +} + +quint8 * MsgPackPrivate::unpack_float64(QVariant &v, quint8 *p) +{ + double d; + quint8 *fd = (quint8 *)&d; + p++; +#ifdef __LITTLE_ENDIAN__ + for (int i = 0; i < 8; ++i) + *(fd + 7 - i) = *(p + i); +#else + for (int i = 0; i < 4; ++i) + *(fp + i) = *(p + i); +#endif + v = d; + return p + 8; +} + +quint8 * MsgPackPrivate::unpack_fixstr(QVariant &v, quint8 *p) +{ + int len = (*p) & 0x1f; // 0b00011111 + p++; + v = QString::fromUtf8((char*)p, len); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_str8(QVariant &v, quint8 *p) +{ + int len = *(++p); + v = QString::fromUtf8((char*)(++p), len); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_str16(QVariant &v, quint8 *p) +{ + p++; + int len = _msgpack_load16(int, p); + p += 2; + v = QString::fromUtf8((char*)p, len); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_str32(QVariant &v, quint8 *p) +{ + p++; + int len = _msgpack_load32(int, p); + p += 4; + v = QString::fromUtf8((char*)p, len); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_bin8(QVariant &v, quint8 *p) +{ + int len = *(++p); + v = QByteArray((char*)(++p), len); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_bin16(QVariant &v, quint8 *p) +{ + p++; + int len = _msgpack_load16(int, p); + p += 2; + v = QByteArray((char*)p, len); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_bin32(QVariant &v, quint8 *p) +{ + p++; + int len = _msgpack_load32(int, p); + p += 4; + v = QByteArray((char*)p, len); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_array_len(QVariant &v, quint8 *p, quint32 len) { - quint32 elemsz = 0; QVariantList arr; + QVariant vu; for (quint32 i = 0; i < len; ++i) { - elemsz = 0; - arr.append(unpack_type(p, elemsz)); - p += elemsz; - sz += elemsz; + p = unpack_type(vu, p); + arr.append(vu); } - return arr; + v = arr; + return p; } -quint32 MsgPackPrivate::unpack_uint8(quint8 *p) +quint8 * MsgPackPrivate::unpack_fixarray(QVariant &v, quint8 *p) { - return *p; -} - - -quint32 MsgPackPrivate::unpack_uint16(quint8 *p) -{ - quint32 val = 0; - quint8 *pv = (quint8 *)&val; - pv[1] = *(p); pv[0] = *(++p); - return val; -} - - -quint32 MsgPackPrivate::unpack_uint32(quint8 *p) -{ - quint32 val = 0; - quint8 *pv = (quint8 *)&val; - pv[3] = *(p); pv[2] = *(++p); - pv[1] = *(++p); pv[0] = *(++p); - return val; -} - -QVariant MsgPackPrivate::unpack_fixarray(quint8 *p, quint32 &sz) -{ - sz += 1; quint32 len = (*p++) & 0x0f; // 0b00001111 - return unpack_array_len(p, sz, len); + return unpack_array_len(v, p, len); } -QVariant MsgPackPrivate::unpack_fixstr(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_array16(QVariant &v, quint8 *p) { - sz += 1; - quint32 len = (*p) & 0x1f; // 0b00011111 - QString str = QString::fromUtf8((char*)(p + 1), len); - sz += len; - return QVariant(str); + p++; + quint32 len = _msgpack_load16(quint32, p); + return unpack_array_len(v, p += 2, len); } -QVariant MsgPackPrivate::unpack_nil(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_array32(QVariant &v, quint8 *p) { - Q_UNUSED(p) - sz += 1; - return 0; + p++; + quint32 len = _msgpack_load32(quint32, p); + return unpack_array_len(v, p += 4, len); } -QVariant MsgPackPrivate::unpack_never_used(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_map_len(QVariant &v, quint8 *p, quint32 len) { - Q_UNUSED(p) - sz += 1; - return QVariant(); + QMap map; + QVariant key, val; + + for (quint32 i = 0; i < len; ++i) { + p = unpack_type(key, p); + p = unpack_true(val, p); + + map.insert(key.toString(), val); + } + v = map; + return p; } -QVariant MsgPackPrivate::unpack_false(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_fixmap(QVariant &v, quint8 *p) { - Q_UNUSED(p) - sz += 1; - return false; + quint32 len = (*p++) & 0x0f; // 0b00001111 + return unpack_map_len(v, p ,len); } -QVariant MsgPackPrivate::unpack_true(quint8 *p, quint32 &sz) +quint8 * MsgPackPrivate::unpack_map16(QVariant &v, quint8 *p) { - Q_UNUSED(p) - sz += 1; + p++; + quint32 len = _msgpack_load16(quint32, p); + return unpack_map_len(v, p += 2, len); +} + +quint8 * MsgPackPrivate::unpack_map32(QVariant &v, quint8 *p) +{ + p++; + quint32 len = _msgpack_load32(quint32, p); + return unpack_map_len(v, p + 4, len); +} + +quint8 *MsgPackPrivate::unpack_ext(QVariant &v, quint8 *p, qint8 type, quint32 len) +{ + if (!user_unpackers.contains(type)) { + qWarning() << "MsgPack::unpack() unpacker for type" << type << "doesn't exist"; + return p + len; + } + QByteArray data((char *)p, len); + v = user_unpackers[type](data); + return p + len; +} + +quint8 * MsgPackPrivate::unpack_fixext1(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + return unpack_ext(v, p + 1, type, 1); +} + +quint8 * MsgPackPrivate::unpack_fixext2(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + return unpack_ext(v, p + 1, type, 2); +} + +quint8 * MsgPackPrivate::unpack_fixext4(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + return unpack_ext(v, p + 1, type, 4); +} + +quint8 * MsgPackPrivate::unpack_fixext8(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + return unpack_ext(v, p + 1, type, 8); +} + +quint8 * MsgPackPrivate::unpack_fixext16(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + return unpack_ext(v, p + 1, type, 16); +} + +quint8 * MsgPackPrivate::unpack_ext8(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + quint32 len = *(p++); + return unpack_ext(v, p + 1, type, len); +} + +quint8 * MsgPackPrivate::unpack_ext16(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + quint32 len = _msgpack_load16(quint32, p); + p += 2; + return unpack_ext(v, p + 1, type, len); +} + +quint8 * MsgPackPrivate::unpack_ext32(QVariant &v, quint8 *p) +{ + qint8 type = *(++p); + quint32 len = _msgpack_load32(quint32, p); + p += 4; + return unpack_ext(v, p + 1, type, len); +} + +bool MsgPackPrivate::register_unpacker(qint8 msgpack_type, MsgPack::unpack_user_f unpacker) +{ + if (user_unpackers.contains(msgpack_type)) { + qWarning() << "MsgPack::unpacker for type" << msgpack_type << "already exists"; + return false; + } + if (unpacker == 0) { + qWarning() << "MsgPack::unpacker for type" << msgpack_type << "is invalid"; + return false; + } + user_unpackers.insert(msgpack_type, unpacker); return true; } - -QVariant MsgPackPrivate::unpack_bin8(quint8 *p, quint32 &sz) -{ - sz += 2; - quint32 len = unpack_uint8(++p); - QByteArray arr((const char *)(p + 1), len); - sz += len; - return arr; -} - -QVariant MsgPackPrivate::unpack_bin16(quint8 *p, quint32 &sz) -{ - sz += 3; - quint32 len = unpack_uint16(++p); - QByteArray arr((const char *)(p + 2), len); - sz += len; - return arr; -} - -QVariant MsgPackPrivate::unpack_bin32(quint8 *p, quint32 &sz) -{ - sz += 5; - quint32 len = unpack_uint32(++p); - QByteArray arr((const char *)(p + 4), len); - sz = len; - return arr; -} - -QVariant MsgPackPrivate::unpack_ext8(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_ext16(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_ext32(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_float32(quint8 *p, quint32 &sz) -{ - sz += 5; - float val = 0; - quint8 *vp = ( (quint8 *)&val ) + 3; - for (int i = 0; i < 4; ++i) - *(vp--) = *(++p); - return val; -} - -QVariant MsgPackPrivate::unpack_float64(quint8 *p, quint32 &sz) -{ - sz += 9; - double val = 0; - quint8 *vp = ( (quint8 *)&val ) + 7; - for (int i = 0; i < 8; ++i) - *(vp--) = *(++p); - return val; -} - -QVariant MsgPackPrivate::unpack_uint8(quint8 *p, quint32 &sz) -{ - sz += 2; - return unpack_uint8(++p); -} - -QVariant MsgPackPrivate::unpack_uint16(quint8 *p, quint32 &sz) -{ - sz += 3; - return unpack_uint16(++p); -} - -QVariant MsgPackPrivate::unpack_uint32(quint8 *p, quint32 &sz) -{ - sz += 5; - return unpack_uint32(++p); -} - -QVariant MsgPackPrivate::unpack_uint64(quint8 *p, quint32 &sz) -{ - sz += 9; - quint64 val = 0; - for (int i = 56; i >= 0; i -= 8) - val |= (quint64)(*(++p)) << i; - return val; -} - -QVariant MsgPackPrivate::unpack_int8(quint8 *p, quint32 &sz) -{ - sz += 2; - qint32 val = 0xffffff00; - val |= *(++p); - return val; -} - -QVariant MsgPackPrivate::unpack_int16(quint8 *p, quint32 &sz) -{ - sz += 3; - qint32 val = 0xffff0000; - quint8 *pv = (quint8 *)&val; - pv[1] = *(++p); pv[0] = *(++p); - return val; -} - -QVariant MsgPackPrivate::unpack_int32(quint8 *p, quint32 &sz) -{ - sz += 5; - qint32 val = 0; - quint8 *pv = (quint8 *)&val; - pv[3] = *(++p); pv[2] = *(++p); - pv[1] = *(++p); pv[0] = *(++p); - return val; -} - -QVariant MsgPackPrivate::unpack_int64(quint8 *p, quint32 &sz) -{ - sz += 9; - qint64 val = 0; - for (int i = 56; i >= 0; i -= 8) - val |= (quint64)(*(++p)) << i; - return val; -} - -QVariant MsgPackPrivate::unpack_fixext1(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_fixext2(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_fixext4(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_fixext8(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_fixext16(quint8 *p, quint32 &sz) -{ - -} - -QVariant MsgPackPrivate::unpack_str8(quint8 *p, quint32 &sz) -{ - sz += 2; - quint32 len = unpack_uint8(++p); - QString str = QString::fromUtf8((char*)(p + 1), len); - sz += len; - return QVariant(str); -} - -QVariant MsgPackPrivate::unpack_str16(quint8 *p, quint32 &sz) -{ - sz += 3; - quint32 len = unpack_uint16(++p); - QString str = QString::fromUtf8((char*)(p + 2), len); - sz += len; - return QVariant(str); -} - -QVariant MsgPackPrivate::unpack_str32(quint8 *p, quint32 &sz) -{ - sz += 5; - quint32 len = unpack_uint32(++p); - QString str = QString::fromUtf8((char*)(p + 4), len); - sz += len; - return QVariant(str); -} - -QVariant MsgPackPrivate::unpack_array16(quint8 *p, quint32 &sz) -{ - sz += 3; - quint32 len = unpack_uint16(++p); - return unpack_array_len(p + 2, sz, len); -} - -QVariant MsgPackPrivate::unpack_array32(quint8 *p, quint32 &sz) -{ - sz += 5; - quint32 len = unpack_uint32(++p); - return unpack_array_len(p + 4, sz, len); -} - -QVariant MsgPackPrivate::unpack_map16(quint8 *p, quint32 &sz) -{ - sz += 3; - quint32 len = unpack_uint16(p); - return unpack_map_len(p + 2, sz, len); -} - -QVariant MsgPackPrivate::unpack_map32(quint8 *p, quint32 &sz) -{ - sz += 5; - quint32 len = unpack_uint32(p); - return unpack_map_len(p + 4, sz, len); -} - - - - diff --git a/private/unpack_p.h b/private/unpack_p.h index 5fb10c1..e9cda80 100644 --- a/private/unpack_p.h +++ b/private/unpack_p.h @@ -1,66 +1,75 @@ #ifndef MSGPACK_P_H #define MSGPACK_P_H #include +#include "../msgpack_common.h" namespace MsgPackPrivate { /* unpack functions: - * QVariant _type_(quint8 *p, quint32 &sz); + * quint8 * _type_(QVariant &v, quint8 *p); * parses some type, which data is stored at p - * fill sz with type size (sz is there at the moment of calling - * parser function) + * type data goes to v + * return pointer to last byte + 1 */ -typedef QVariant (* type_parser_f)(quint8 *p, quint32 &sz); +typedef quint8 * (* type_parser_f)(QVariant &v, quint8 *p); extern type_parser_f unpackers[32]; +bool register_unpacker(qint8 msgpack_type, MsgPack::unpack_user_f unpacker); +extern QHash user_unpackers; + // goes from p to end unpacking types with unpack_type function below QVariant unpack(quint8 *p, quint8 *end); // unpack some type, can be called recursively from other unpack functions -QVariant unpack_type(quint8 *p, quint32 &sz); +quint8 * unpack_type(QVariant &v, quint8 *p); -QVariant unpack_map_len(quint8 *p, quint32 &sz, quint32 len); -QVariant unpack_array_len(quint8 *p, quint32 &sz, quint32 len); -quint32 unpack_uint8(quint8 *p); -quint32 unpack_uint16(quint8 *p); -quint32 unpack_uint32(quint8 *p); +quint8 * unpack_nil(QVariant &v, quint8 *p); +quint8 * unpack_never_used(QVariant &v, quint8 *p); +quint8 * unpack_false(QVariant &v, quint8 *p); +quint8 * unpack_true(QVariant &v, 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); -QVariant unpack_fixarray(quint8 *p, quint32 &sz); -QVariant unpack_fixstr(quint8 *p, quint32 &sz); -QVariant unpack_nil(quint8 *p, quint32 &sz); -QVariant unpack_never_used(quint8 *p, quint32 &sz); -QVariant unpack_false(quint8 *p, quint32 &sz); -QVariant unpack_true(quint8 *p, quint32 &sz); -QVariant unpack_bin8(quint8 *p, quint32 &sz); -QVariant unpack_bin16(quint8 *p, quint32 &sz); -QVariant unpack_bin32(quint8 *p, quint32 &sz); -QVariant unpack_ext8(quint8 *p, quint32 &sz); -QVariant unpack_ext16(quint8 *p, quint32 &sz); -QVariant unpack_ext32(quint8 *p, quint32 &sz); -QVariant unpack_float32(quint8 *p, quint32 &sz); -QVariant unpack_float64(quint8 *p, quint32 &sz); -QVariant unpack_uint8(quint8 *p, quint32 &sz); -QVariant unpack_uint16(quint8 *p, quint32 &sz); -QVariant unpack_uint32(quint8 *p, quint32 &sz); -QVariant unpack_uint64(quint8 *p, quint32 &sz); -QVariant unpack_int8(quint8 *p, quint32 &sz); -QVariant unpack_int16(quint8 *p, quint32 &sz); -QVariant unpack_int32(quint8 *p, quint32 &sz); -QVariant unpack_int64(quint8 *p, quint32 &sz); -QVariant unpack_fixext1(quint8 *p, quint32 &sz); -QVariant unpack_fixext2(quint8 *p, quint32 &sz); -QVariant unpack_fixext4(quint8 *p, quint32 &sz); -QVariant unpack_fixext8(quint8 *p, quint32 &sz); -QVariant unpack_fixext16(quint8 *p, quint32 &sz); -QVariant unpack_str8(quint8 *p, quint32 &sz); -QVariant unpack_str16(quint8 *p, quint32 &sz); -QVariant unpack_str32(quint8 *p, quint32 &sz); -QVariant unpack_array16(quint8 *p, quint32 &sz); -QVariant unpack_array32(quint8 *p, quint32 &sz); -QVariant unpack_map16(quint8 *p, quint32 &sz); -QVariant unpack_map32(quint8 *p, quint32 &sz); +quint8 * unpack_positive_fixint(QVariant &v, quint8 *p); +quint8 * unpack_negative_fixint(QVariant &v, quint8 *p); +quint8 * unpack_uint8(QVariant &v, quint8 *p); +quint8 * unpack_uint16(QVariant &v, quint8 *p); +quint8 * unpack_uint32(QVariant &v, quint8 *p); +quint8 * unpack_uint64(QVariant &v, quint8 *p); +quint8 * unpack_int8(QVariant &v, quint8 *p); +quint8 * unpack_int16(QVariant &v, quint8 *p); +quint8 * unpack_int32(QVariant &v, quint8 *p); +quint8 * unpack_int64(QVariant &v, quint8 *p); + +quint8 * unpack_float32(QVariant &v, quint8 *p); +quint8 * unpack_float64(QVariant &v, quint8 *p); + +quint8 * unpack_fixstr(QVariant &v, quint8 *p); +quint8 * unpack_str8(QVariant &v, quint8 *p); +quint8 * unpack_str16(QVariant &v, quint8 *p); +quint8 * unpack_str32(QVariant &v, quint8 *p); + +quint8 * unpack_bin8(QVariant &v, quint8 *p); +quint8 * unpack_bin16(QVariant &v, quint8 *p); +quint8 * unpack_bin32(QVariant &v, quint8 *p); + +quint8 * unpack_array_len(QVariant &v, quint8 *p, quint32 len); +quint8 * unpack_fixarray(QVariant &v, quint8 *p); +quint8 * unpack_array16(QVariant &v, quint8 *p); +quint8 * unpack_array32(QVariant &v, quint8 *p); + +quint8 * unpack_map_len(QVariant &v, quint8 *p, quint32 len); +quint8 * unpack_fixmap(QVariant &v, quint8 *p); +quint8 * unpack_map16(QVariant &v, quint8 *p); +quint8 * unpack_map32(QVariant &v, quint8 *p); + +quint8 * unpack_ext(QVariant &v, quint8 *p, qint8 type, quint32 len); +quint8 * unpack_fixext1(QVariant &v, quint8 *p); +quint8 * unpack_fixext2(QVariant &v, quint8 *p); +quint8 * unpack_fixext4(QVariant &v, quint8 *p); +quint8 * unpack_fixext8(QVariant &v, quint8 *p); +quint8 * unpack_fixext16(QVariant &v, quint8 *p); + +quint8 * unpack_ext8(QVariant &v, quint8 *p); +quint8 * unpack_ext16(QVariant &v, quint8 *p); +quint8 * unpack_ext32(QVariant &v, quint8 *p); } #endif // MSGPACK_P_H