romixlab/qmsgpack
1
0
Fork 1
mirror of https://github.com/romixlab/qmsgpack.git synced 2025-06-25 01:21:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

user type unpacking implemented, unpack code reorganized

Browse Source
This commit is contained in:
romixlab
2014-09-19 23:26:24 +04:00
parent 640f6fa155
commit 39a26510dc
7 changed files with 396 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
main.cpp
View File

@ -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();

6
msgpack.cpp
View File

@ -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);
}

1
msgpack.h
View File

@ -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);

8
msgpack_common.h
View File

@ -4,7 +4,15 @@
#include <QVariant>
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

8
private/pack_p.cpp
View File

@ -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;

613
private/unpack_p.cpp
View File

@ -1,4 +1,5 @@
#include "unpack_p.h"
#include "sysdep.h"
#include <QDebug>
MsgPackPrivate::type_parser_f MsgPackPrivate::unpackers[32] = {
@ -16,15 +17,16 @@ MsgPackPrivate::type_parser_f MsgPackPrivate::unpackers[32] = {
unpack_map16, unpack_map32
};
QHash<qint8, MsgPack::unpack_user_f> 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<QString, QVariant> 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<QString, QVariant> 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);
}

103
private/unpack_p.h
View File

@ -1,66 +1,75 @@
#ifndef MSGPACK_P_H
#define MSGPACK_P_H
#include <QVariant>
#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<qint8, MsgPack::unpack_user_f> 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