pack.hpp
Go to the documentation of this file.
//
// MessagePack for C++ serializing routine
//
// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef MSGPACK_V1_PACK_HPP
#define MSGPACK_V1_PACK_HPP
#include "msgpack/v1/pack_decl.hpp"
#include <stdexcept>
#include <limits>
#include <cstring>
#include <climits>
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(v1) {
template <typename Stream>
class packer {
public:
packer(Stream* s);
packer(Stream& s);
public:
template <typename T>
packer<Stream>& pack(const T& v);
packer<Stream>& pack_uint8(uint8_t d);
packer<Stream>& pack_uint16(uint16_t d);
packer<Stream>& pack_uint32(uint32_t d);
packer<Stream>& pack_uint64(uint64_t d);
packer<Stream>& pack_int8(int8_t d);
packer<Stream>& pack_int16(int16_t d);
packer<Stream>& pack_int32(int32_t d);
packer<Stream>& pack_int64(int64_t d);
packer<Stream>& pack_fix_uint8(uint8_t d);
packer<Stream>& pack_fix_uint16(uint16_t d);
packer<Stream>& pack_fix_uint32(uint32_t d);
packer<Stream>& pack_fix_uint64(uint64_t d);
packer<Stream>& pack_fix_int8(int8_t d);
packer<Stream>& pack_fix_int16(int16_t d);
packer<Stream>& pack_fix_int32(int32_t d);
packer<Stream>& pack_fix_int64(int64_t d);
packer<Stream>& pack_char(char d);
packer<Stream>& pack_signed_char(signed char d);
packer<Stream>& pack_short(short d);
packer<Stream>& pack_int(int d);
packer<Stream>& pack_long(long d);
packer<Stream>& pack_long_long(long long d);
packer<Stream>& pack_unsigned_char(unsigned char d);
packer<Stream>& pack_unsigned_short(unsigned short d);
packer<Stream>& pack_unsigned_int(unsigned int d);
packer<Stream>& pack_unsigned_long(unsigned long d);
packer<Stream>& pack_unsigned_long_long(unsigned long long d);
packer<Stream>& pack_float(float d);
packer<Stream>& pack_double(double d);
packer<Stream>& pack_nil();
packer<Stream>& pack_true();
packer<Stream>& pack_false();
packer<Stream>& pack_array(uint32_t n);
packer<Stream>& pack_map(uint32_t n);
packer<Stream>& pack_str(uint32_t l);
packer<Stream>& pack_str_body(const char* b, uint32_t l);
packer<Stream>& pack_v4raw(uint32_t l);
packer<Stream>& pack_v4raw_body(const char* b, uint32_t l);
packer<Stream>& pack_bin(uint32_t l);
packer<Stream>& pack_bin_body(const char* b, uint32_t l);
packer<Stream>& pack_ext(size_t l, int8_t type);
packer<Stream>& pack_ext_body(const char* b, uint32_t l);
private:
template <typename T>
void pack_imp_uint8(T d);
template <typename T>
void pack_imp_uint16(T d);
template <typename T>
void pack_imp_uint32(T d);
template <typename T>
void pack_imp_uint64(T d);
template <typename T>
void pack_imp_int8(T d);
template <typename T>
void pack_imp_int16(T d);
template <typename T>
void pack_imp_int32(T d);
template <typename T>
void pack_imp_int64(T d);
void append_buffer(const char* buf, size_t len)
{ m_stream.write(buf, len); }
private:
Stream& m_stream;
#if defined(MSGPACK_USE_CPP03)
private:
packer(const packer&);
packer& operator=(const packer&);
packer();
#else // defined(MSGPACK_USE_CPP03)
public:
packer(const packer&) = delete;
packer& operator=(const packer&) = delete;
packer() = delete;
#endif // defined(MSGPACK_USE_CPP03)
};
template <typename Stream, typename T>
inline void pack(Stream* s, const T& v)
{
packer<Stream>(*s).pack(v);
}
template <typename Stream, typename T>
inline void pack(Stream& s, const T& v)
{
packer<Stream>(s).pack(v);
}
#if MSGPACK_ENDIAN_LITTLE_BYTE
template <typename T>
inline char take8_8(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
}
template <typename T>
inline char take8_16(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
}
template <typename T>
inline char take8_32(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
}
template <typename T>
inline char take8_64(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
}
#elif MSGPACK_ENDIAN_BIG_BYTE
template <typename T>
inline char take8_8(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[0]);
}
template <typename T>
inline char take8_16(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[1]);
}
template <typename T>
inline char take8_32(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[3]);
}
template <typename T>
inline char take8_64(T d) {
return static_cast<char>(reinterpret_cast<uint8_t*>(&d)[7]);
}
#else
#error msgpack-c supports only big endian and little endian
#endif
template <typename Stream>
inline packer<Stream>::packer(Stream* s) : m_stream(*s) { }
template <typename Stream>
inline packer<Stream>::packer(Stream& s) : m_stream(s) { }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_uint8(uint8_t d)
{ pack_imp_uint8(d); return *this; }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_uint16(uint16_t d)
{ pack_imp_uint16(d); return *this; }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_uint32(uint32_t d)
{ pack_imp_uint32(d); return *this; }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_uint64(uint64_t d)
{ pack_imp_uint64(d); return *this; }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_int8(int8_t d)
{ pack_imp_int8(d); return *this; }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_int16(int16_t d)
{ pack_imp_int16(d); return *this; }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_int32(int32_t d)
{ pack_imp_int32(d); return *this; }
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_int64(int64_t d)
{ pack_imp_int64(d); return *this;}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_uint8(uint8_t d)
{
char buf[2] = {static_cast<char>(0xccu), take8_8(d)};
append_buffer(buf, 2);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_uint16(uint16_t d)
{
char buf[3];
buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], d);
append_buffer(buf, 3);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_uint32(uint32_t d)
{
char buf[5];
buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], d);
append_buffer(buf, 5);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_uint64(uint64_t d)
{
char buf[9];
buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
append_buffer(buf, 9);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_int8(int8_t d)
{
char buf[2] = {static_cast<char>(0xd0u), take8_8(d)};
append_buffer(buf, 2);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_int16(int16_t d)
{
char buf[3];
buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], d);
append_buffer(buf, 3);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_int32(int32_t d)
{
char buf[5];
buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], d);
append_buffer(buf, 5);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_fix_int64(int64_t d)
{
char buf[9];
buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
append_buffer(buf, 9);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_char(char d)
{
#if defined(CHAR_MIN)
#if CHAR_MIN < 0
pack_imp_int8(d);
#else
pack_imp_uint8(d);
#endif
#else
#error CHAR_MIN is not defined
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_signed_char(signed char d)
{
pack_imp_int8(d);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_short(short d)
{
#if defined(SIZEOF_SHORT)
#if SIZEOF_SHORT == 2
pack_imp_int16(d);
#elif SIZEOF_SHORT == 4
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#elif defined(SHRT_MAX)
#if SHRT_MAX == 0x7fff
pack_imp_int16(d);
#elif SHRT_MAX == 0x7fffffff
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#else
if(sizeof(short) == 2) {
pack_imp_int16(d);
} else if(sizeof(short) == 4) {
pack_imp_int32(d);
} else {
pack_imp_int64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_int(int d)
{
#if defined(SIZEOF_INT)
#if SIZEOF_INT == 2
pack_imp_int16(d);
#elif SIZEOF_INT == 4
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#elif defined(INT_MAX)
#if INT_MAX == 0x7fff
pack_imp_int16(d);
#elif INT_MAX == 0x7fffffff
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#else
if(sizeof(int) == 2) {
pack_imp_int16(d);
} else if(sizeof(int) == 4) {
pack_imp_int32(d);
} else {
pack_imp_int64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_long(long d)
{
#if defined(SIZEOF_LONG)
#if SIZEOF_LONG == 2
pack_imp_int16(d);
#elif SIZEOF_LONG == 4
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#elif defined(LONG_MAX)
#if LONG_MAX == 0x7fffL
pack_imp_int16(d);
#elif LONG_MAX == 0x7fffffffL
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#else
if(sizeof(long) == 2) {
pack_imp_int16(d);
} else if(sizeof(long) == 4) {
pack_imp_int32(d);
} else {
pack_imp_int64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_long_long(long long d)
{
#if defined(SIZEOF_LONG_LONG)
#if SIZEOF_LONG_LONG == 2
pack_imp_int16(d);
#elif SIZEOF_LONG_LONG == 4
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#elif defined(LLONG_MAX)
#if LLONG_MAX == 0x7fffL
pack_imp_int16(d);
#elif LLONG_MAX == 0x7fffffffL
pack_imp_int32(d);
#else
pack_imp_int64(d);
#endif
#else
if(sizeof(long long) == 2) {
pack_imp_int16(d);
} else if(sizeof(long long) == 4) {
pack_imp_int32(d);
} else {
pack_imp_int64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_unsigned_char(unsigned char d)
{
pack_imp_uint8(d);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_unsigned_short(unsigned short d)
{
#if defined(SIZEOF_SHORT)
#if SIZEOF_SHORT == 2
pack_imp_uint16(d);
#elif SIZEOF_SHORT == 4
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#elif defined(USHRT_MAX)
#if USHRT_MAX == 0xffffU
pack_imp_uint16(d);
#elif USHRT_MAX == 0xffffffffU
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#else
if(sizeof(unsigned short) == 2) {
pack_imp_uint16(d);
} else if(sizeof(unsigned short) == 4) {
pack_imp_uint32(d);
} else {
pack_imp_uint64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_unsigned_int(unsigned int d)
{
#if defined(SIZEOF_INT)
#if SIZEOF_INT == 2
pack_imp_uint16(d);
#elif SIZEOF_INT == 4
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#elif defined(UINT_MAX)
#if UINT_MAX == 0xffffU
pack_imp_uint16(d);
#elif UINT_MAX == 0xffffffffU
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#else
if(sizeof(unsigned int) == 2) {
pack_imp_uint16(d);
} else if(sizeof(unsigned int) == 4) {
pack_imp_uint32(d);
} else {
pack_imp_uint64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_unsigned_long(unsigned long d)
{
#if defined(SIZEOF_LONG)
#if SIZEOF_LONG == 2
pack_imp_uint16(d);
#elif SIZEOF_LONG == 4
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#elif defined(ULONG_MAX)
#if ULONG_MAX == 0xffffUL
pack_imp_uint16(d);
#elif ULONG_MAX == 0xffffffffUL
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#else
if(sizeof(unsigned long) == 2) {
pack_imp_uint16(d);
} else if(sizeof(unsigned long) == 4) {
pack_imp_uint32(d);
} else {
pack_imp_uint64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_unsigned_long_long(unsigned long long d)
{
#if defined(SIZEOF_LONG_LONG)
#if SIZEOF_LONG_LONG == 2
pack_imp_uint16(d);
#elif SIZEOF_LONG_LONG == 4
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#elif defined(ULLONG_MAX)
#if ULLONG_MAX == 0xffffUL
pack_imp_uint16(d);
#elif ULLONG_MAX == 0xffffffffUL
pack_imp_uint32(d);
#else
pack_imp_uint64(d);
#endif
#else
if(sizeof(unsigned long long) == 2) {
pack_imp_uint16(d);
} else if(sizeof(unsigned long long) == 4) {
pack_imp_uint32(d);
} else {
pack_imp_uint64(d);
}
#endif
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_float(float d)
{
union { float f; uint32_t i; } mem;
mem.f = d;
char buf[5];
buf[0] = static_cast<char>(0xcau); _msgpack_store32(&buf[1], mem.i);
append_buffer(buf, 5);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_double(double d)
{
union { double f; uint64_t i; } mem;
mem.f = d;
char buf[9];
buf[0] = static_cast<char>(0xcbu);
#if defined(TARGET_OS_IPHONE)
// ok
#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi
// https://github.com/msgpack/msgpack-perl/pull/1
mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
#endif
_msgpack_store64(&buf[1], mem.i);
append_buffer(buf, 9);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_nil()
{
const char d = static_cast<char>(0xc0u);
append_buffer(&d, 1);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_true()
{
const char d = static_cast<char>(0xc3u);
append_buffer(&d, 1);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_false()
{
const char d = static_cast<char>(0xc2u);
append_buffer(&d, 1);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_array(uint32_t n)
{
if(n < 16) {
char d = static_cast<char>(0x90u | n);
append_buffer(&d, 1);
} else if(n < 65536) {
char buf[3];
buf[0] = static_cast<char>(0xdcu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
append_buffer(buf, 3);
} else {
char buf[5];
buf[0] = static_cast<char>(0xddu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
append_buffer(buf, 5);
}
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_map(uint32_t n)
{
if(n < 16) {
unsigned char d = static_cast<unsigned char>(0x80u | n);
char buf = take8_8(d);
append_buffer(&buf, 1);
} else if(n < 65536) {
char buf[3];
buf[0] = static_cast<char>(0xdeu); _msgpack_store16(&buf[1], static_cast<uint16_t>(n));
append_buffer(buf, 3);
} else {
char buf[5];
buf[0] = static_cast<char>(0xdfu); _msgpack_store32(&buf[1], static_cast<uint32_t>(n));
append_buffer(buf, 5);
}
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_str(uint32_t l)
{
if(l < 32) {
unsigned char d = static_cast<uint8_t>(0xa0u | l);
char buf = take8_8(d);
append_buffer(&buf, 1);
} else if(l < 256) {
char buf[2];
buf[0] = static_cast<char>(0xd9u); buf[1] = static_cast<uint8_t>(l);
append_buffer(buf, 2);
} else if(l < 65536) {
char buf[3];
buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
append_buffer(buf, 3);
} else {
char buf[5];
buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
append_buffer(buf, 5);
}
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_str_body(const char* b, uint32_t l)
{
append_buffer(b, l);
return *this;
}
// Raw (V4)
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_v4raw(uint32_t l)
{
if(l < 32) {
unsigned char d = static_cast<uint8_t>(0xa0u | l);
char buf = take8_8(d);
append_buffer(&buf, 1);
} else if(l < 65536) {
char buf[3];
buf[0] = static_cast<char>(0xdau); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
append_buffer(buf, 3);
} else {
char buf[5];
buf[0] = static_cast<char>(0xdbu); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
append_buffer(buf, 5);
}
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_v4raw_body(const char* b, uint32_t l)
{
append_buffer(b, l);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_bin(uint32_t l)
{
if(l < 256) {
char buf[2];
buf[0] = static_cast<char>(0xc4u); buf[1] = static_cast<uint8_t>(l);
append_buffer(buf, 2);
} else if(l < 65536) {
char buf[3];
buf[0] = static_cast<char>(0xc5u); _msgpack_store16(&buf[1], static_cast<uint16_t>(l));
append_buffer(buf, 3);
} else {
char buf[5];
buf[0] = static_cast<char>(0xc6u); _msgpack_store32(&buf[1], static_cast<uint32_t>(l));
append_buffer(buf, 5);
}
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_bin_body(const char* b, uint32_t l)
{
append_buffer(b, l);
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_ext(size_t l, int8_t type)
{
switch(l) {
case 1: {
char buf[2];
buf[0] = static_cast<char>(0xd4u);
buf[1] = static_cast<char>(type);
append_buffer(buf, 2);
} break;
case 2: {
char buf[2];
buf[0] = static_cast<char>(0xd5u);
buf[1] = static_cast<char>(type);
append_buffer(buf, 2);
} break;
case 4: {
char buf[2];
buf[0] = static_cast<char>(0xd6u);
buf[1] = static_cast<char>(type);
append_buffer(buf, 2);
} break;
case 8: {
char buf[2];
buf[0] = static_cast<char>(0xd7u);
buf[1] = static_cast<char>(type);
append_buffer(buf, 2);
} break;
case 16: {
char buf[2];
buf[0] = static_cast<char>(0xd8u);
buf[1] = static_cast<char>(type);
append_buffer(buf, 2);
} break;
default:
if(l < 256) {
char buf[3];
buf[0] = static_cast<char>(0xc7u);
buf[1] = static_cast<char>(l);
buf[2] = static_cast<char>(type);
append_buffer(buf, 3);
} else if(l < 65536) {
char buf[4];
buf[0] = static_cast<char>(0xc8u);
_msgpack_store16(&buf[1], static_cast<uint16_t>(l));
buf[3] = static_cast<char>(type);
append_buffer(buf, 4);
} else {
char buf[6];
buf[0] = static_cast<char>(0xc9u);
_msgpack_store32(&buf[1], static_cast<uint32_t>(l));
buf[5] = static_cast<char>(type);
append_buffer(buf, 6);
}
break;
}
return *this;
}
template <typename Stream>
inline packer<Stream>& packer<Stream>::pack_ext_body(const char* b, uint32_t l)
{
append_buffer(b, l);
return *this;
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_uint8(T d)
{
if(d < (1<<7)) {
/* fixnum */
char buf = take8_8(d);
append_buffer(&buf, 1);
} else {
/* unsigned 8 */
char buf[2] = {static_cast<char>(0xccu), take8_8(d)};
append_buffer(buf, 2);
}
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_uint16(T d)
{
if(d < (1<<7)) {
/* fixnum */
char buf = take8_16(d);
append_buffer(&buf, 1);
} else if(d < (1<<8)) {
/* unsigned 8 */
char buf[2] = {static_cast<char>(0xccu), take8_16(d)};
append_buffer(buf, 2);
} else {
/* unsigned 16 */
char buf[3];
buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
append_buffer(buf, 3);
}
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_uint32(T d)
{
if(d < (1<<8)) {
if(d < (1<<7)) {
/* fixnum */
char buf = take8_32(d);
append_buffer(&buf, 1);
} else {
/* unsigned 8 */
char buf[2] = {static_cast<char>(0xccu), take8_32(d)};
append_buffer(buf, 2);
}
} else {
if(d < (1<<16)) {
/* unsigned 16 */
char buf[3];
buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
append_buffer(buf, 3);
} else {
/* unsigned 32 */
char buf[5];
buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
append_buffer(buf, 5);
}
}
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_uint64(T d)
{
if(d < (1ULL<<8)) {
if(d < (1ULL<<7)) {
/* fixnum */
char buf = take8_64(d);
append_buffer(&buf, 1);
} else {
/* unsigned 8 */
char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
append_buffer(buf, 2);
}
} else {
if(d < (1ULL<<16)) {
/* unsigned 16 */
char buf[3];
buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
append_buffer(buf, 3);
} else if(d < (1ULL<<32)) {
/* unsigned 32 */
char buf[5];
buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
append_buffer(buf, 5);
} else {
/* unsigned 64 */
char buf[9];
buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
append_buffer(buf, 9);
}
}
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_int8(T d)
{
if(d < -(1<<5)) {
/* signed 8 */
char buf[2] = {static_cast<char>(0xd0u), take8_8(d)};
append_buffer(buf, 2);
} else {
/* fixnum */
char buf = take8_8(d);
append_buffer(&buf, 1);
}
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_int16(T d)
{
if(d < -(1<<5)) {
if(d < -(1<<7)) {
/* signed 16 */
char buf[3];
buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
append_buffer(buf, 3);
} else {
/* signed 8 */
char buf[2] = {static_cast<char>(0xd0u), take8_16(d)};
append_buffer(buf, 2);
}
} else if(d < (1<<7)) {
/* fixnum */
char buf = take8_16(d);
append_buffer(&buf, 1);
} else {
if(d < (1<<8)) {
/* unsigned 8 */
char buf[2] = {static_cast<char>(0xccu), take8_16(d)};
append_buffer(buf, 2);
} else {
/* unsigned 16 */
char buf[3];
buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
append_buffer(buf, 3);
}
}
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_int32(T d)
{
if(d < -(1<<5)) {
if(d < -(1<<15)) {
/* signed 32 */
char buf[5];
buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
append_buffer(buf, 5);
} else if(d < -(1<<7)) {
/* signed 16 */
char buf[3];
buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
append_buffer(buf, 3);
} else {
/* signed 8 */
char buf[2] = { static_cast<char>(0xd0u), take8_32(d)};
append_buffer(buf, 2);
}
} else if(d < (1<<7)) {
/* fixnum */
char buf = take8_32(d);
append_buffer(&buf, 1);
} else {
if(d < (1<<8)) {
/* unsigned 8 */
char buf[2] = { static_cast<char>(0xccu), take8_32(d)};
append_buffer(buf, 2);
} else if(d < (1<<16)) {
/* unsigned 16 */
char buf[3];
buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
append_buffer(buf, 3);
} else {
/* unsigned 32 */
char buf[5];
buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
append_buffer(buf, 5);
}
}
}
template <typename Stream>
template <typename T>
inline void packer<Stream>::pack_imp_int64(T d)
{
if(d < -(1LL<<5)) {
if(d < -(1LL<<15)) {
if(d < -(1LL<<31)) {
/* signed 64 */
char buf[9];
buf[0] = static_cast<char>(0xd3u); _msgpack_store64(&buf[1], d);
append_buffer(buf, 9);
} else {
/* signed 32 */
char buf[5];
buf[0] = static_cast<char>(0xd2u); _msgpack_store32(&buf[1], static_cast<int32_t>(d));
append_buffer(buf, 5);
}
} else {
if(d < -(1<<7)) {
/* signed 16 */
char buf[3];
buf[0] = static_cast<char>(0xd1u); _msgpack_store16(&buf[1], static_cast<int16_t>(d));
append_buffer(buf, 3);
} else {
/* signed 8 */
char buf[2] = {static_cast<char>(0xd0u), take8_64(d)};
append_buffer(buf, 2);
}
}
} else if(d < (1<<7)) {
/* fixnum */
char buf = take8_64(d);
append_buffer(&buf, 1);
} else {
if(d < (1LL<<16)) {
if(d < (1<<8)) {
/* unsigned 8 */
char buf[2] = {static_cast<char>(0xccu), take8_64(d)};
append_buffer(buf, 2);
} else {
/* unsigned 16 */
char buf[3];
buf[0] = static_cast<char>(0xcdu); _msgpack_store16(&buf[1], static_cast<uint16_t>(d));
append_buffer(buf, 3);
}
} else {
if(d < (1LL<<32)) {
/* unsigned 32 */
char buf[5];
buf[0] = static_cast<char>(0xceu); _msgpack_store32(&buf[1], static_cast<uint32_t>(d));
append_buffer(buf, 5);
} else {
/* unsigned 64 */
char buf[9];
buf[0] = static_cast<char>(0xcfu); _msgpack_store64(&buf[1], d);
append_buffer(buf, 9);
}
}
}
}
} // MSGPACK_API_VERSION_NAMESPACE(v1)
} // namespace msgpack
#endif // MSGPACK_V1_PACK_HPP
msgpack::packer::pack_bin
packer< Stream > & pack_bin(uint32_t l)
Packing bin header and length.
Definition: pack.hpp:1255
msgpack::packer::pack_fix_uint16
packer< Stream > & pack_fix_uint16(uint16_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:746
msgpack::packer::pack_fix_uint32
packer< Stream > & pack_fix_uint32(uint32_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:755
msgpack::packer::pack_char
packer< Stream > & pack_char(char d)
Packing char.
Definition: pack.hpp:809
msgpack::packer::pack_v4raw
packer< Stream > & pack_v4raw(uint32_t l)
Packing raw (v4) header and length.
Definition: pack.hpp:1229
msgpack::packer::pack_long_long
packer< Stream > & pack_long_long(long long d)
Packing long long.
Definition: pack.hpp:930
msgpack::packer::pack_ext
packer< Stream > & pack_ext(size_t l, int8_t type)
Packing ext header, type, and length.
Definition: pack.hpp:1281
msgpack::packer::pack_uint16
packer< Stream > & pack_uint16(uint16_t d)
Packing uint16.
Definition: pack.hpp:709
msgpack::packer::operator=
packer & operator=(const packer &)=delete
msgpack::packer::pack_unsigned_int
packer< Stream > & pack_unsigned_int(unsigned int d)
Packing unsigned int.
Definition: pack.hpp:1004
msgpack::packer::pack_short
packer< Stream > & pack_short(short d)
Packing short.
Definition: pack.hpp:831
msgpack::packer::pack_long
packer< Stream > & pack_long(long d)
Packing long.
Definition: pack.hpp:897
msgpack::packer::pack_array
packer< Stream > & pack_array(uint32_t n)
Packing array header and size.
Definition: pack.hpp:1160
msgpack::packer::pack_uint64
packer< Stream > & pack_uint64(uint64_t d)
Packing uint16.
Definition: pack.hpp:717
msgpack
Definition: adaptor_base.hpp:15
msgpack::packer::pack_int64
packer< Stream > & pack_int64(int64_t d)
Packing int32.
Definition: pack.hpp:733
pack_decl.hpp
msgpack::packer::pack_uint8
packer< Stream > & pack_uint8(uint8_t d)
Packing uint8.
Definition: pack.hpp:705
msgpack::packer::pack_bin_body
packer< Stream > & pack_bin_body(const char *b, uint32_t l)
Packing bin body.
Definition: pack.hpp:1274
msgpack::packer::pack_false
packer< Stream > & pack_false()
Packing false.
Definition: pack.hpp:1151
msgpack::packer::pack
packer< Stream > & pack(const T &v)
Packing function template.
msgpack::packer::pack_str_body
packer< Stream > & pack_str_body(const char *b, uint32_t l)
Packing str body.
Definition: pack.hpp:1220
msgpack::packer::pack_int16
packer< Stream > & pack_int16(int16_t d)
Packing int16.
Definition: pack.hpp:725
msgpack::packer::pack_true
packer< Stream > & pack_true()
Packing true.
Definition: pack.hpp:1143
msgpack::packer::pack_uint32
packer< Stream > & pack_uint32(uint32_t d)
Packing uint32.
Definition: pack.hpp:713
msgpack::packer::pack_fix_int32
packer< Stream > & pack_fix_int32(int32_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:790
msgpack::packer::pack_unsigned_short
packer< Stream > & pack_unsigned_short(unsigned short d)
Packing unsigned short.
Definition: pack.hpp:971
msgpack::packer::pack_map
packer< Stream > & pack_map(uint32_t n)
Packing map header and size.
Definition: pack.hpp:1178
msgpack::packer::pack_int32
packer< Stream > & pack_int32(int32_t d)
Packing int32.
Definition: pack.hpp:729
msgpack::packer::packer
packer()=delete
msgpack::packer::pack_float
packer< Stream > & pack_float(float d)
Packing float.
Definition: pack.hpp:1104
msgpack::packer::pack_v4raw_body
packer< Stream > & pack_v4raw_body(const char *b, uint32_t l)
Packing raw (v4) body.
Definition: pack.hpp:1248
msgpack::packer::pack_double
packer< Stream > & pack_double(double d)
Packing double.
Definition: pack.hpp:1115
msgpack::packer::pack_ext_body
packer< Stream > & pack_ext_body(const char *b, uint32_t l)
Packing ext body.
Definition: pack.hpp:1340
MSGPACK_API_VERSION_NAMESPACE
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
msgpack::packer::pack_fix_int16
packer< Stream > & pack_fix_int16(int16_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:781
msgpack::packer::pack_int8
packer< Stream > & pack_int8(int8_t d)
Packing int8.
Definition: pack.hpp:721
msgpack::packer::pack_fix_int8
packer< Stream > & pack_fix_int8(int8_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:773
msgpack::packer
The class template that supports continuous packing.
Definition: adaptor_base_decl.hpp:24
msgpack::packer::pack_fix_uint8
packer< Stream > & pack_fix_uint8(uint8_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:738
msgpack::packer::pack_signed_char
packer< Stream > & pack_signed_char(signed char d)
Packing signed char.
Definition: pack.hpp:824
msgpack::packer::pack_fix_uint64
packer< Stream > & pack_fix_uint64(uint64_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:764
msgpack::packer::pack_nil
packer< Stream > & pack_nil()
Packing nil.
Definition: pack.hpp:1135
msgpack::packer::pack_str
packer< Stream > & pack_str(uint32_t l)
Packing str header and length.
Definition: pack.hpp:1197
msgpack::packer::pack_unsigned_long
packer< Stream > & pack_unsigned_long(unsigned long d)
Packing unsigned long.
Definition: pack.hpp:1037
msgpack::packer::pack_unsigned_long_long
packer< Stream > & pack_unsigned_long_long(unsigned long long d)
Packing unsigned long long.
Definition: pack.hpp:1070
msgpack::packer::pack_int
packer< Stream > & pack_int(int d)
Packing int.
Definition: pack.hpp:864
msgpack::packer::pack_fix_int64
packer< Stream > & pack_fix_int64(int64_t d)
Packing uint8 (fixed packed type).
Definition: pack.hpp:799
msgpack::packer::pack_unsigned_char
packer< Stream > & pack_unsigned_char(unsigned char d)
Packing unsigned char.
Definition: pack.hpp:964