10 #ifndef MSGPACK_PACK_HPP 11 #define MSGPACK_PACK_HPP 34 template <
typename Stream>
61 packer<Stream>&
pack(
const T& v);
485 packer<Stream>&
pack_map(uint32_t n);
499 packer<Stream>&
pack_str(uint32_t l);
551 packer<Stream>&
pack_bin(uint32_t l);
577 packer<Stream>&
pack_ext(
size_t l, int8_t type);
592 template <
typename T>
593 void pack_imp_uint8(T d);
594 template <
typename T>
595 void pack_imp_uint16(T d);
596 template <
typename T>
597 void pack_imp_uint32(T d);
598 template <
typename T>
599 void pack_imp_uint64(T d);
600 template <
typename T>
601 void pack_imp_int8(T d);
602 template <
typename T>
603 void pack_imp_int16(T d);
604 template <
typename T>
605 void pack_imp_int32(T d);
606 template <
typename T>
607 void pack_imp_int64(T d);
609 void append_buffer(
const char* buf,
size_t len)
610 { m_stream.write(buf, len); }
615 #if defined(MSGPACK_USE_CPP03) 620 #else // defined(MSGPACK_USE_CPP03) 625 #endif // defined(MSGPACK_USE_CPP03) 639 template <
typename Stream,
typename T>
640 inline void pack(Stream* s,
const T& v)
652 template <
typename Stream,
typename T>
653 inline void pack(Stream& s,
const T& v)
659 #if MSGPACK_ENDIAN_LITTLE_BYTE 660 template <
typename T>
661 inline char take8_8(T d) {
662 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[0]);
664 template <
typename T>
665 inline char take8_16(T d) {
666 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[0]);
668 template <
typename T>
669 inline char take8_32(T d) {
670 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[0]);
672 template <
typename T>
673 inline char take8_64(T d) {
674 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[0]);
677 #elif MSGPACK_ENDIAN_BIG_BYTE 679 template <
typename T>
680 inline char take8_8(T d) {
681 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[0]);
683 template <
typename T>
684 inline char take8_16(T d) {
685 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[1]);
687 template <
typename T>
688 inline char take8_32(T d) {
689 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[3]);
691 template <
typename T>
692 inline char take8_64(T d) {
693 return static_cast<char>(
reinterpret_cast<uint8_t*
>(&d)[7]);
697 #error msgpack-c supports only big endian and little endian 700 template <
typename Stream>
703 template <
typename Stream>
707 template <
typename Stream>
709 { pack_imp_uint8(d);
return *
this; }
711 template <
typename Stream>
713 { pack_imp_uint16(d);
return *
this; }
715 template <
typename Stream>
717 { pack_imp_uint32(d);
return *
this; }
719 template <
typename Stream>
721 { pack_imp_uint64(d);
return *
this; }
723 template <
typename Stream>
725 { pack_imp_int8(d);
return *
this; }
727 template <
typename Stream>
729 { pack_imp_int16(d);
return *
this; }
731 template <
typename Stream>
733 { pack_imp_int32(d);
return *
this; }
735 template <
typename Stream>
737 { pack_imp_int64(d);
return *
this;}
740 template <
typename Stream>
743 char buf[2] = {
static_cast<char>(0xccu), take8_8(d)};
744 append_buffer(buf, 2);
748 template <
typename Stream>
752 buf[0] =
static_cast<char>(0xcdu); _msgpack_store16(&buf[1], d);
753 append_buffer(buf, 3);
757 template <
typename Stream>
761 buf[0] =
static_cast<char>(0xceu); _msgpack_store32(&buf[1], d);
762 append_buffer(buf, 5);
766 template <
typename Stream>
770 buf[0] =
static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
771 append_buffer(buf, 9);
775 template <
typename Stream>
778 char buf[2] = {
static_cast<char>(0xd0u), take8_8(d)};
779 append_buffer(buf, 2);
783 template <
typename Stream>
787 buf[0] =
static_cast<char>(0xd1u); _msgpack_store16(&buf[1], d);
788 append_buffer(buf, 3);
792 template <
typename Stream>
796 buf[0] =
static_cast<char>(0xd2u); _msgpack_store32(&buf[1], d);
797 append_buffer(buf, 5);
801 template <
typename Stream>
805 buf[0] =
static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
806 append_buffer(buf, 9);
811 template <
typename Stream>
814 #if defined(CHAR_MIN) 821 #error CHAR_MIN is not defined 826 template <
typename Stream>
833 template <
typename Stream>
836 #if defined(SIZEOF_SHORT) 837 #if SIZEOF_SHORT == 2 839 #elif SIZEOF_SHORT == 4 845 #elif defined(SHRT_MAX) 846 #if SHRT_MAX == 0x7fff 848 #elif SHRT_MAX == 0x7fffffff 855 if(
sizeof(
short) == 2) {
857 }
else if(
sizeof(
short) == 4) {
866 template <
typename Stream>
869 #if defined(SIZEOF_INT) 872 #elif SIZEOF_INT == 4 878 #elif defined(INT_MAX) 879 #if INT_MAX == 0x7fff 881 #elif INT_MAX == 0x7fffffff 888 if(
sizeof(
int) == 2) {
890 }
else if(
sizeof(
int) == 4) {
899 template <
typename Stream>
902 #if defined(SIZEOF_LONG) 905 #elif SIZEOF_LONG == 4 911 #elif defined(LONG_MAX) 912 #if LONG_MAX == 0x7fffL 914 #elif LONG_MAX == 0x7fffffffL 921 if(
sizeof(
long) == 2) {
923 }
else if(
sizeof(
long) == 4) {
932 template <
typename Stream>
935 #if defined(SIZEOF_LONG_LONG) 936 #if SIZEOF_LONG_LONG == 2 938 #elif SIZEOF_LONG_LONG == 4 944 #elif defined(LLONG_MAX) 945 #if LLONG_MAX == 0x7fffL 947 #elif LLONG_MAX == 0x7fffffffL 954 if(
sizeof(
long long) == 2) {
956 }
else if(
sizeof(
long long) == 4) {
966 template <
typename Stream>
973 template <
typename Stream>
976 #if defined(SIZEOF_SHORT) 977 #if SIZEOF_SHORT == 2 979 #elif SIZEOF_SHORT == 4 985 #elif defined(USHRT_MAX) 986 #if USHRT_MAX == 0xffffU 988 #elif USHRT_MAX == 0xffffffffU 995 if(
sizeof(
unsigned short) == 2) {
997 }
else if(
sizeof(
unsigned short) == 4) {
1006 template <
typename Stream>
1009 #if defined(SIZEOF_INT) 1012 #elif SIZEOF_INT == 4 1018 #elif defined(UINT_MAX) 1019 #if UINT_MAX == 0xffffU 1021 #elif UINT_MAX == 0xffffffffU 1028 if(
sizeof(
unsigned int) == 2) {
1030 }
else if(
sizeof(
unsigned int) == 4) {
1039 template <
typename Stream>
1042 #if defined(SIZEOF_LONG) 1043 #if SIZEOF_LONG == 2 1045 #elif SIZEOF_LONG == 4 1051 #elif defined(ULONG_MAX) 1052 #if ULONG_MAX == 0xffffUL 1054 #elif ULONG_MAX == 0xffffffffUL 1061 if(
sizeof(
unsigned long) == 2) {
1063 }
else if(
sizeof(
unsigned long) == 4) {
1072 template <
typename Stream>
1075 #if defined(SIZEOF_LONG_LONG) 1076 #if SIZEOF_LONG_LONG == 2 1078 #elif SIZEOF_LONG_LONG == 4 1084 #elif defined(ULLONG_MAX) 1085 #if ULLONG_MAX == 0xffffUL 1087 #elif ULLONG_MAX == 0xffffffffUL 1094 if(
sizeof(
unsigned long long) == 2) {
1096 }
else if(
sizeof(
unsigned long long) == 4) {
1106 template <
typename Stream>
1109 union {
float f; uint32_t i; } mem;
1112 buf[0] =
static_cast<char>(0xcau); _msgpack_store32(&buf[1], mem.i);
1113 append_buffer(buf, 5);
1117 template <
typename Stream>
1120 union {
double f; uint64_t i; } mem;
1123 buf[0] =
static_cast<char>(0xcbu);
1125 #if defined(TARGET_OS_IPHONE) 1127 #elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi 1129 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
1131 _msgpack_store64(&buf[1], mem.i);
1132 append_buffer(buf, 9);
1137 template <
typename Stream>
1140 const char d =
static_cast<char>(0xc0u);
1141 append_buffer(&d, 1);
1145 template <
typename Stream>
1148 const char d =
static_cast<char>(0xc3u);
1149 append_buffer(&d, 1);
1153 template <
typename Stream>
1156 const char d =
static_cast<char>(0xc2u);
1157 append_buffer(&d, 1);
1162 template <
typename Stream>
1166 char d =
static_cast<char>(0x90u | n);
1167 append_buffer(&d, 1);
1168 }
else if(n < 65536) {
1170 buf[0] =
static_cast<char>(0xdcu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
1171 append_buffer(buf, 3);
1174 buf[0] =
static_cast<char>(0xddu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
1175 append_buffer(buf, 5);
1180 template <
typename Stream>
1184 unsigned char d =
static_cast<unsigned char>(0x80u | n);
1185 char buf = take8_8(d);
1186 append_buffer(&buf, 1);
1187 }
else if(n < 65536) {
1189 buf[0] =
static_cast<char>(0xdeu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
1190 append_buffer(buf, 3);
1193 buf[0] =
static_cast<char>(0xdfu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
1194 append_buffer(buf, 5);
1199 template <
typename Stream>
1203 unsigned char d =
static_cast<uint8_t
>(0xa0u | l);
1204 char buf = take8_8(d);
1205 append_buffer(&buf, 1);
1206 }
else if(l < 256) {
1208 buf[0] =
static_cast<char>(0xd9u); buf[1] =
static_cast<uint8_t
>(l);
1209 append_buffer(buf, 2);
1210 }
else if(l < 65536) {
1212 buf[0] =
static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
1213 append_buffer(buf, 3);
1216 buf[0] =
static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
1217 append_buffer(buf, 5);
1222 template <
typename Stream>
1225 append_buffer(b, l);
1231 template <
typename Stream>
1235 unsigned char d =
static_cast<uint8_t
>(0xa0u | l);
1236 char buf = take8_8(d);
1237 append_buffer(&buf, 1);
1238 }
else if(l < 65536) {
1240 buf[0] =
static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
1241 append_buffer(buf, 3);
1244 buf[0] =
static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
1245 append_buffer(buf, 5);
1250 template <
typename Stream>
1253 append_buffer(b, l);
1257 template <
typename Stream>
1262 buf[0] =
static_cast<char>(0xc4u); buf[1] =
static_cast<uint8_t
>(l);
1263 append_buffer(buf, 2);
1264 }
else if(l < 65536) {
1266 buf[0] =
static_cast<char>(0xc5u); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
1267 append_buffer(buf, 3);
1270 buf[0] =
static_cast<char>(0xc6u); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
1271 append_buffer(buf, 5);
1276 template <
typename Stream>
1279 append_buffer(b, l);
1283 template <
typename Stream>
1289 buf[0] =
static_cast<char>(0xd4u);
1290 buf[1] =
static_cast<char>(type);
1291 append_buffer(buf, 2);
1295 buf[0] =
static_cast<char>(0xd5u);
1296 buf[1] =
static_cast<char>(type);
1297 append_buffer(buf, 2);
1301 buf[0] =
static_cast<char>(0xd6u);
1302 buf[1] =
static_cast<char>(type);
1303 append_buffer(buf, 2);
1307 buf[0] =
static_cast<char>(0xd7u);
1308 buf[1] =
static_cast<char>(type);
1309 append_buffer(buf, 2);
1313 buf[0] =
static_cast<char>(0xd8u);
1314 buf[1] =
static_cast<char>(type);
1315 append_buffer(buf, 2);
1320 buf[0] =
static_cast<char>(0xc7u);
1321 buf[1] =
static_cast<char>(l);
1322 buf[2] =
static_cast<char>(type);
1323 append_buffer(buf, 3);
1324 }
else if(l < 65536) {
1326 buf[0] =
static_cast<char>(0xc8u);
1327 _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
1328 buf[3] =
static_cast<char>(type);
1329 append_buffer(buf, 4);
1332 buf[0] =
static_cast<char>(0xc9u);
1333 _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
1334 buf[5] =
static_cast<char>(type);
1335 append_buffer(buf, 6);
1342 template <
typename Stream>
1345 append_buffer(b, l);
1349 template <
typename Stream>
1350 template <
typename T>
1355 char buf = take8_8(d);
1356 append_buffer(&buf, 1);
1359 char buf[2] = {
static_cast<char>(0xccu), take8_8(d)};
1360 append_buffer(buf, 2);
1364 template <
typename Stream>
1365 template <
typename T>
1370 char buf = take8_16(d);
1371 append_buffer(&buf, 1);
1372 }
else if(d < (1<<8)) {
1374 char buf[2] = {
static_cast<char>(0xccu), take8_16(d)};
1375 append_buffer(buf, 2);
1379 buf[0] =
static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
1380 append_buffer(buf, 3);
1384 template <
typename Stream>
1385 template <
typename T>
1391 char buf = take8_32(d);
1392 append_buffer(&buf, 1);
1395 char buf[2] = {
static_cast<char>(0xccu), take8_32(d)};
1396 append_buffer(buf, 2);
1402 buf[0] =
static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
1403 append_buffer(buf, 3);
1407 buf[0] =
static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
1408 append_buffer(buf, 5);
1413 template <
typename Stream>
1414 template <
typename T>
1420 char buf = take8_64(d);
1421 append_buffer(&buf, 1);
1424 char buf[2] = {
static_cast<char>(0xccu), take8_64(d)};
1425 append_buffer(buf, 2);
1428 if(d < (1ULL<<16)) {
1431 buf[0] =
static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
1432 append_buffer(buf, 3);
1433 }
else if(d < (1ULL<<32)) {
1436 buf[0] =
static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
1437 append_buffer(buf, 5);
1441 buf[0] =
static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
1442 append_buffer(buf, 9);
1447 template <
typename Stream>
1448 template <
typename T>
1453 char buf[2] = {
static_cast<char>(0xd0u), take8_8(d)};
1454 append_buffer(buf, 2);
1457 char buf = take8_8(d);
1458 append_buffer(&buf, 1);
1462 template <
typename Stream>
1463 template <
typename T>
1470 buf[0] =
static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
1471 append_buffer(buf, 3);
1474 char buf[2] = {
static_cast<char>(0xd0u), take8_16(d)};
1475 append_buffer(buf, 2);
1477 }
else if(d < (1<<7)) {
1479 char buf = take8_16(d);
1480 append_buffer(&buf, 1);
1484 char buf[2] = {
static_cast<char>(0xccu), take8_16(d)};
1485 append_buffer(buf, 2);
1489 buf[0] =
static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
1490 append_buffer(buf, 3);
1495 template <
typename Stream>
1496 template <
typename T>
1503 buf[0] =
static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
1504 append_buffer(buf, 5);
1505 }
else if(d < -(1<<7)) {
1508 buf[0] =
static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
1509 append_buffer(buf, 3);
1512 char buf[2] = {
static_cast<char>(0xd0u), take8_32(d)};
1513 append_buffer(buf, 2);
1515 }
else if(d < (1<<7)) {
1517 char buf = take8_32(d);
1518 append_buffer(&buf, 1);
1522 char buf[2] = {
static_cast<char>(0xccu), take8_32(d)};
1523 append_buffer(buf, 2);
1524 }
else if(d < (1<<16)) {
1527 buf[0] =
static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
1528 append_buffer(buf, 3);
1532 buf[0] =
static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
1533 append_buffer(buf, 5);
1538 template <
typename Stream>
1539 template <
typename T>
1543 if(d < -(1LL<<15)) {
1544 if(d < -(1LL<<31)) {
1547 buf[0] =
static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
1548 append_buffer(buf, 9);
1552 buf[0] =
static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
1553 append_buffer(buf, 5);
1559 buf[0] =
static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
1560 append_buffer(buf, 3);
1563 char buf[2] = {
static_cast<char>(0xd0u), take8_64(d)};
1564 append_buffer(buf, 2);
1567 }
else if(d < (1<<7)) {
1569 char buf = take8_64(d);
1570 append_buffer(&buf, 1);
1575 char buf[2] = {
static_cast<char>(0xccu), take8_64(d)};
1576 append_buffer(buf, 2);
1580 buf[0] =
static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
1581 append_buffer(buf, 3);
1587 buf[0] =
static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
1588 append_buffer(buf, 5);
1592 buf[0] =
static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
1593 append_buffer(buf, 9);
packer< Stream > & pack_bin(uint32_t l)
Packing bin header and length.
Definition: pack.hpp:1258
packer< Stream > & pack_fix_uint16(uint16_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:749
packer< Stream > & pack_fix_uint32(uint32_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:758
packer< Stream > & pack_char(char d)
Packing char.
Definition: pack.hpp:812
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
packer< Stream > & pack_v4raw(uint32_t l)
Packing raw (v4) header and length.
Definition: pack.hpp:1232
packer< Stream > & pack_long_long(long long d)
Packing long long.
Definition: pack.hpp:933
packer< Stream > & pack_ext(size_t l, int8_t type)
Packing ext header, type, and length.
Definition: pack.hpp:1284
packer< Stream > & pack_uint16(uint16_t d)
Packing uint16.
Definition: pack.hpp:712
packer & operator=(const packer &)=delete
packer< Stream > & pack_unsigned_int(unsigned int d)
Packing unsigned int.
Definition: pack.hpp:1007
packer< Stream > & pack_short(short d)
Packing short.
Definition: pack.hpp:834
packer< Stream > & pack_long(long d)
Packing long.
Definition: pack.hpp:900
packer< Stream > & pack_array(uint32_t n)
Packing array header and size.
Definition: pack.hpp:1163
packer< Stream > & pack_uint64(uint64_t d)
Packing uint16.
Definition: pack.hpp:720
Definition: adaptor_base.hpp:15
packer< Stream > & pack_int64(int64_t d)
Packing int32.
Definition: pack.hpp:736
packer< Stream > & pack_uint8(uint8_t d)
Packing uint8.
Definition: pack.hpp:708
packer< Stream > & pack_bin_body(const char *b, uint32_t l)
Packing bin body.
Definition: pack.hpp:1277
packer< Stream > & pack_false()
Packing false.
Definition: pack.hpp:1154
packer< Stream > & pack(const T &v)
Packing function template.
packer< Stream > & pack_str_body(const char *b, uint32_t l)
Packing str body.
Definition: pack.hpp:1223
packer< Stream > & pack_int16(int16_t d)
Packing int16.
Definition: pack.hpp:728
packer< Stream > & pack_true()
Packing true.
Definition: pack.hpp:1146
packer< Stream > & pack_uint32(uint32_t d)
Packing uint32.
Definition: pack.hpp:716
packer< Stream > & pack_fix_int32(int32_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:793
packer< Stream > & pack_unsigned_short(unsigned short d)
Packing unsigned short.
Definition: pack.hpp:974
packer< Stream > & pack_map(uint32_t n)
Packing map header and size.
Definition: pack.hpp:1181
packer< Stream > & pack_int32(int32_t d)
Packing int32.
Definition: pack.hpp:732
packer< Stream > & pack_float(float d)
Packing float.
Definition: pack.hpp:1107
packer< Stream > & pack_v4raw_body(const char *b, uint32_t l)
Packing raw (v4) body.
Definition: pack.hpp:1251
packer< Stream > & pack_double(double d)
Packing double.
Definition: pack.hpp:1118
packer< Stream > & pack_ext_body(const char *b, uint32_t l)
Packing ext body.
Definition: pack.hpp:1343
packer< Stream > & pack_fix_int16(int16_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:784
packer< Stream > & pack_int8(int8_t d)
Packing int8.
Definition: pack.hpp:724
packer< Stream > & pack_fix_int8(int8_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:776
The class template that supports continuous packing.
Definition: adaptor_base.hpp:22
packer< Stream > & pack_fix_uint8(uint8_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:741
packer< Stream > & pack_signed_char(signed char d)
Packing signed char.
Definition: pack.hpp:827
packer< Stream > & pack_fix_uint64(uint64_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:767
packer< Stream > & pack_nil()
Packing nil.
Definition: pack.hpp:1138
packer< Stream > & pack_str(uint32_t l)
Packing str header and length.
Definition: pack.hpp:1200
packer< Stream > & pack_unsigned_long(unsigned long d)
Packing unsigned long.
Definition: pack.hpp:1040
packer< Stream > & pack_unsigned_long_long(unsigned long long d)
Packing unsigned long long.
Definition: pack.hpp:1073
packer< Stream > & pack_int(int d)
Packing int.
Definition: pack.hpp:867
packer< Stream > & pack_fix_int64(int64_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:802
packer< Stream > & pack_unsigned_char(unsigned char d)
Packing unsigned char.
Definition: pack.hpp:967