unpack.hpp
Go to the documentation of this file.
//
// MessagePack for C++ deserializing 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_UNPACK_HPP
#define MSGPACK_V1_UNPACK_HPP
#include "msgpack/versioning.hpp"
#include "msgpack/unpack_decl.hpp"
#include "msgpack/object.hpp"
#include "msgpack/zone.hpp"
#include "msgpack/unpack_exception.hpp"
#include "msgpack/unpack_define.h"
#include "msgpack/cpp_config.hpp"
#include "msgpack/sysdep.h"
#include <memory>
#if !defined(MSGPACK_USE_CPP03)
#include <atomic>
#endif
#if defined(_MSC_VER)
// avoiding confliction std::max, std::min, and macro in windows.h
#ifndef NOMINMAX
#define NOMINMAX
#endif
#endif // defined(_MSC_VER)
namespace msgpack {
MSGPACK_API_VERSION_NAMESPACE(v1) {
namespace detail {
class unpack_user {
public:
unpack_user(unpack_reference_func f = MSGPACK_NULLPTR,
void* user_data = MSGPACK_NULLPTR,
unpack_limit const& limit = unpack_limit())
:m_func(f), m_user_data(user_data), m_limit(limit) {}
msgpack::zone const& zone() const { return *m_zone; }
msgpack::zone& zone() { return *m_zone; }
void set_zone(msgpack::zone& zone) { m_zone = &zone; }
bool referenced() const { return m_referenced; }
void set_referenced(bool referenced) { m_referenced = referenced; }
unpack_reference_func reference_func() const { return m_func; }
void* user_data() const { return m_user_data; }
unpack_limit const& limit() const { return m_limit; }
unpack_limit& limit() { return m_limit; }
private:
msgpack::zone* m_zone;
bool m_referenced;
unpack_reference_func m_func;
void* m_user_data;
unpack_limit m_limit;
};
inline void unpack_uint8(uint8_t d, msgpack::object& o)
{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_uint16(uint16_t d, msgpack::object& o)
{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_uint32(uint32_t d, msgpack::object& o)
{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_uint64(uint64_t d, msgpack::object& o)
{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_int8(int8_t d, msgpack::object& o)
{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_int16(int16_t d, msgpack::object& o)
{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_int32(int32_t d, msgpack::object& o)
{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_int64(int64_t d, msgpack::object& o)
{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_float(float d, msgpack::object& o)
{ o.type = msgpack::type::FLOAT32; o.via.f64 = d; }
inline void unpack_double(double d, msgpack::object& o)
{ o.type = msgpack::type::FLOAT64; o.via.f64 = d; }
inline void unpack_nil(msgpack::object& o)
{ o.type = msgpack::type::NIL; }
inline void unpack_true(msgpack::object& o)
{ o.type = msgpack::type::BOOLEAN; o.via.boolean = true; }
inline void unpack_false(msgpack::object& o)
{ o.type = msgpack::type::BOOLEAN; o.via.boolean = false; }
struct unpack_array {
void operator()(unpack_user& u, uint32_t n, msgpack::object& o) const {
if (n > u.limit().array()) throw msgpack::array_size_overflow("array size overflow");
o.type = msgpack::type::ARRAY;
o.via.array.size = 0;
size_t size = n*sizeof(msgpack::object);
if (size / sizeof(msgpack::object) != n) {
throw msgpack::array_size_overflow("array size overflow");
}
o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
}
};
inline void unpack_array_item(msgpack::object& c, msgpack::object const& o)
{
#if defined(__GNUC__) && !defined(__clang__)
std::memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(msgpack::object));
#else /* __GNUC__ && !__clang__ */
c.via.array.ptr[c.via.array.size++] = o;
#endif /* __GNUC__ && !__clang__ */
}
struct unpack_map {
void operator()(unpack_user& u, uint32_t n, msgpack::object& o) const {
if (n > u.limit().map()) throw msgpack::map_size_overflow("map size overflow");
o.type = msgpack::type::MAP;
o.via.map.size = 0;
size_t size = n*sizeof(msgpack::object_kv);
if (size / sizeof(msgpack::object_kv) != n) {
throw msgpack::map_size_overflow("map size overflow");
}
o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
}
};
inline void unpack_map_item(msgpack::object& c, msgpack::object const& k, msgpack::object const& v)
{
#if defined(__GNUC__) && !defined(__clang__)
std::memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(msgpack::object));
std::memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(msgpack::object));
#else /* __GNUC__ && !__clang__ */
c.via.map.ptr[c.via.map.size].key = k;
c.via.map.ptr[c.via.map.size].val = v;
#endif /* __GNUC__ && !__clang__ */
++c.via.map.size;
}
inline void unpack_str(unpack_user& u, const char* p, uint32_t l, msgpack::object& o)
{
o.type = msgpack::type::STR;
if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) {
o.via.str.ptr = p;
u.set_referenced(true);
}
else {
if (l > u.limit().str()) throw msgpack::str_size_overflow("str size overflow");
char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
std::memcpy(tmp, p, l);
o.via.str.ptr = tmp;
}
o.via.str.size = l;
}
inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, msgpack::object& o)
{
o.type = msgpack::type::BIN;
if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) {
o.via.bin.ptr = p;
u.set_referenced(true);
}
else {
if (l > u.limit().bin()) throw msgpack::bin_size_overflow("bin size overflow");
char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
std::memcpy(tmp, p, l);
o.via.bin.ptr = tmp;
}
o.via.bin.size = l;
}
inline void unpack_ext(unpack_user& u, const char* p, std::size_t l, msgpack::object& o)
{
o.type = msgpack::type::EXT;
if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) {
o.via.ext.ptr = p;
u.set_referenced(true);
}
else {
if (l > u.limit().ext()) throw msgpack::ext_size_overflow("ext size overflow");
char* tmp = static_cast<char*>(u.zone().allocate_align(l, MSGPACK_ZONE_ALIGNOF(char)));
std::memcpy(tmp, p, l);
o.via.ext.ptr = tmp;
}
o.via.ext.size = static_cast<uint32_t>(l - 1);
}
class unpack_stack {
public:
msgpack::object const& obj() const { return m_obj; }
msgpack::object& obj() { return m_obj; }
void set_obj(msgpack::object const& obj) { m_obj = obj; }
std::size_t count() const { return m_count; }
void set_count(std::size_t count) { m_count = count; }
std::size_t decr_count() { return --m_count; }
uint32_t container_type() const { return m_container_type; }
void set_container_type(uint32_t container_type) { m_container_type = container_type; }
msgpack::object const& map_key() const { return m_map_key; }
void set_map_key(msgpack::object const& map_key) { m_map_key = map_key; }
private:
msgpack::object m_obj;
std::size_t m_count;
uint32_t m_container_type;
msgpack::object m_map_key;
};
inline void init_count(void* buffer)
{
#if defined(MSGPACK_USE_CPP03)
*reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer) = 1;
#else // defined(MSGPACK_USE_CPP03)
new (buffer) std::atomic<unsigned int>(1);
#endif // defined(MSGPACK_USE_CPP03)
}
inline void decr_count(void* buffer)
{
#if defined(MSGPACK_USE_CPP03)
if(_msgpack_sync_decr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer)) == 0) {
free(buffer);
}
#else // defined(MSGPACK_USE_CPP03)
if (--*reinterpret_cast<std::atomic<unsigned int>*>(buffer) == 0) {
free(buffer);
}
#endif // defined(MSGPACK_USE_CPP03)
}
inline void incr_count(void* buffer)
{
#if defined(MSGPACK_USE_CPP03)
_msgpack_sync_incr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer));
#else // defined(MSGPACK_USE_CPP03)
++*reinterpret_cast<std::atomic<unsigned int>*>(buffer);
#endif // defined(MSGPACK_USE_CPP03)
}
#if defined(MSGPACK_USE_CPP03)
inline _msgpack_atomic_counter_t get_count(void* buffer)
{
return *reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer);
}
#else // defined(MSGPACK_USE_CPP03)
inline std::atomic<unsigned int> const& get_count(void* buffer)
{
return *reinterpret_cast<std::atomic<unsigned int>*>(buffer);
}
#endif // defined(MSGPACK_USE_CPP03)
template <typename T>
struct value {
typedef T type;
};
template <>
struct value<fix_tag> {
typedef uint32_t type;
};
template <typename T>
inline typename msgpack::enable_if<sizeof(T) == sizeof(fix_tag)>::type load(uint32_t& dst, const char* n) {
dst = static_cast<uint32_t>(*reinterpret_cast<const uint8_t*>(n)) & 0x0f;
}
template <typename T>
inline typename msgpack::enable_if<sizeof(T) == 1>::type load(T& dst, const char* n) {
dst = static_cast<T>(*reinterpret_cast<const uint8_t*>(n));
}
template <typename T>
inline typename msgpack::enable_if<sizeof(T) == 2>::type load(T& dst, const char* n) {
_msgpack_load16(T, n, &dst);
}
template <typename T>
inline typename msgpack::enable_if<sizeof(T) == 4>::type load(T& dst, const char* n) {
_msgpack_load32(T, n, &dst);
}
template <typename T>
inline typename msgpack::enable_if<sizeof(T) == 8>::type load(T& dst, const char* n) {
_msgpack_load64(T, n, &dst);
}
class context {
public:
context(unpack_reference_func f, void* user_data, unpack_limit const& limit)
:m_trail(0), m_user(f, user_data, limit), m_cs(MSGPACK_CS_HEADER)
{
m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
m_stack.push_back(unpack_stack());
}
void init()
{
m_cs = MSGPACK_CS_HEADER;
m_trail = 0;
m_stack.resize(1);
m_stack[0].set_obj(msgpack::object());
}
msgpack::object const& data() const
{
return m_stack[0].obj();
}
unpack_user& user()
{
return m_user;
}
unpack_user const& user() const
{
return m_user;
}
int execute(const char* data, std::size_t len, std::size_t& off);
private:
template <typename T>
static uint32_t next_cs(T p)
{
return static_cast<uint32_t>(*p) & 0x1f;
}
template <typename T, typename Func>
int push_aggregate(
Func const& f,
uint32_t container_type,
msgpack::object& obj,
const char* load_pos,
std::size_t& off) {
typename value<T>::type tmp;
load<T>(tmp, load_pos);
f(m_user, tmp, m_stack.back().obj());
if(tmp == 0) {
obj = m_stack.back().obj();
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_stack.back().set_container_type(container_type);
m_stack.back().set_count(tmp);
if (m_stack.size() <= m_user.limit().depth()) {
m_stack.push_back(unpack_stack());
}
else {
throw msgpack::depth_size_overflow("depth size overflow");
}
m_cs = MSGPACK_CS_HEADER;
++m_current;
}
return 0;
}
int push_item(msgpack::object& obj) {
bool finish = false;
while (!finish) {
if(m_stack.size() == 1) {
return 1;
}
unpack_stack& sp = *(m_stack.end() - 2);
switch(sp.container_type()) {
case MSGPACK_CT_ARRAY_ITEM:
unpack_array_item(sp.obj(), obj);
if(sp.decr_count() == 0) {
obj = sp.obj();
m_stack.pop_back();
}
else {
finish = true;
}
break;
case MSGPACK_CT_MAP_KEY:
sp.set_map_key(obj);
sp.set_container_type(MSGPACK_CT_MAP_VALUE);
finish = true;
break;
case MSGPACK_CT_MAP_VALUE:
unpack_map_item(sp.obj(), sp.map_key(), obj);
if(sp.decr_count() == 0) {
obj = sp.obj();
m_stack.pop_back();
}
else {
sp.set_container_type(MSGPACK_CT_MAP_KEY);
finish = true;
}
break;
default:
return -1;
}
}
return 0;
}
int push_proc(msgpack::object& obj, std::size_t& off) {
int ret = push_item(obj);
if (ret > 0) {
m_stack[0].set_obj(obj);
++m_current;
/*printf("-- finish --\n"); */
off = m_current - m_start;
}
else if (ret < 0) {
off = m_current - m_start;
}
else {
m_cs = MSGPACK_CS_HEADER;
++m_current;
}
return ret;
}
template <std::size_t N>
static void check_ext_size(std::size_t /*size*/) {
}
private:
char const* m_start;
char const* m_current;
std::size_t m_trail;
unpack_user m_user;
uint32_t m_cs;
std::vector<unpack_stack> m_stack;
};
template <>
inline void context::check_ext_size<4>(std::size_t size) {
if (size == 0xffffffff) throw msgpack::ext_size_overflow("ext size overflow");
}
inline int context::execute(const char* data, std::size_t len, std::size_t& off)
{
assert(len >= off);
m_start = data;
m_current = data + off;
const char* const pe = data + len;
const char* n = MSGPACK_NULLPTR;
msgpack::object obj;
if(m_current == pe) {
off = m_current - m_start;
return 0;
}
bool fixed_trail_again = false;
do {
if (m_cs == MSGPACK_CS_HEADER) {
fixed_trail_again = false;
int selector = *reinterpret_cast<const unsigned char*>(m_current);
if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum
unpack_uint8(*reinterpret_cast<const uint8_t*>(m_current), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum
unpack_int8(*reinterpret_cast<const int8_t*>(m_current), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} else if (0xc4 <= selector && selector <= 0xdf) {
const uint32_t trail[] = {
1, // bin 8 0xc4
2, // bin 16 0xc5
4, // bin 32 0xc6
1, // ext 8 0xc7
2, // ext 16 0xc8
4, // ext 32 0xc9
4, // float 32 0xca
8, // float 64 0xcb
1, // uint 8 0xcc
2, // uint 16 0xcd
4, // uint 32 0xce
8, // uint 64 0xcf
1, // int 8 0xd0
2, // int 16 0xd1
4, // int 32 0xd2
8, // int 64 0xd3
2, // fixext 1 0xd4
3, // fixext 2 0xd5
5, // fixext 4 0xd6
9, // fixext 8 0xd7
17,// fixext 16 0xd8
1, // str 8 0xd9
2, // str 16 0xda
4, // str 32 0xdb
2, // array 16 0xdc
4, // array 32 0xdd
2, // map 16 0xde
4, // map 32 0xdf
};
m_trail = trail[selector - 0xc4];
m_cs = next_cs(m_current);
fixed_trail_again = true;
} else if(0xa0 <= selector && selector <= 0xbf) { // FixStr
m_trail = static_cast<uint32_t>(*m_current) & 0x1f;
if(m_trail == 0) {
unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} else if(0x90 <= selector && selector <= 0x9f) { // FixArray
int ret = push_aggregate<fix_tag>(
unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, m_current, off);
if (ret != 0) return ret;
} else if(0x80 <= selector && selector <= 0x8f) { // FixMap
int ret = push_aggregate<fix_tag>(
unpack_map(), MSGPACK_CT_MAP_KEY, obj, m_current, off);
if (ret != 0) return ret;
} else if(selector == 0xc2) { // false
unpack_false(obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} else if(selector == 0xc3) { // true
unpack_true(obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} else if(selector == 0xc0) { // nil
unpack_nil(obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} else {
off = m_current - m_start;
return -1;
}
// end MSGPACK_CS_HEADER
}
if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) {
if (fixed_trail_again) {
++m_current;
fixed_trail_again = false;
}
if(static_cast<std::size_t>(pe - m_current) < m_trail) {
off = m_current - m_start;
return 0;
}
n = m_current;
m_current += m_trail - 1;
switch(m_cs) {
//case MSGPACK_CS_
//case MSGPACK_CS_
case MSGPACK_CS_FLOAT: {
union { uint32_t i; float f; } mem;
load<uint32_t>(mem.i, n);
unpack_float(mem.f, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_DOUBLE: {
union { uint64_t i; double f; } mem;
load<uint64_t>(mem.i, n);
#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
unpack_double(mem.f, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_UINT_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
unpack_uint8(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_UINT_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
unpack_uint16(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_UINT_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
unpack_uint32(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_UINT_64: {
uint64_t tmp;
load<uint64_t>(tmp, n);
unpack_uint64(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_INT_8: {
int8_t tmp;
load<int8_t>(tmp, n);
unpack_int8(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_INT_16: {
int16_t tmp;
load<int16_t>(tmp, n);
unpack_int16(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_INT_32: {
int32_t tmp;
load<int32_t>(tmp, n);
unpack_int32(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_INT_64: {
int64_t tmp;
load<int64_t>(tmp, n);
unpack_int64(tmp, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_FIXEXT_1: {
unpack_ext(m_user, n, 1+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_FIXEXT_2: {
unpack_ext(m_user, n, 2+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_FIXEXT_4: {
unpack_ext(m_user, n, 4+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_FIXEXT_8: {
unpack_ext(m_user, n, 8+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_FIXEXT_16: {
unpack_ext(m_user, n, 16+1, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_STR_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_BIN_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_EXT_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp + 1;
if(m_trail == 0) {
unpack_ext(m_user, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_EXT_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_STR_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_BIN_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_EXT_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp + 1;
if(m_trail == 0) {
unpack_ext(m_user, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_EXT_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_STR_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_BIN_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_CS_EXT_32: {
uint32_t tmp;
load<uint32_t>(tmp, n);
check_ext_size<sizeof(std::size_t)>(tmp);
m_trail = tmp;
++m_trail;
if(m_trail == 0) {
unpack_ext(m_user, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = MSGPACK_ACS_EXT_VALUE;
fixed_trail_again = true;
}
} break;
case MSGPACK_ACS_STR_VALUE: {
unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_ACS_BIN_VALUE: {
unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_ACS_EXT_VALUE: {
unpack_ext(m_user, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_ARRAY_16: {
int ret = push_aggregate<uint16_t>(
unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_ARRAY_32: {
/* FIXME security guard */
int ret = push_aggregate<uint32_t>(
unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_MAP_16: {
int ret = push_aggregate<uint16_t>(
unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off);
if (ret != 0) return ret;
} break;
case MSGPACK_CS_MAP_32: {
/* FIXME security guard */
int ret = push_aggregate<uint32_t>(
unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off);
if (ret != 0) return ret;
} break;
default:
off = m_current - m_start;
return -1;
}
}
} while(m_current != pe);
off = m_current - m_start;
return 0;
}
} // detail
class unpacker {
public:
unpacker(unpack_reference_func f = &unpacker::default_reference_func,
void* user_data = MSGPACK_NULLPTR,
std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
unpack_limit const& limit = unpack_limit());
#if !defined(MSGPACK_USE_CPP03)
unpacker(unpacker&& other);
unpacker& operator=(unpacker&& other);
#endif // !defined(MSGPACK_USE_CPP03)
~unpacker();
public:
void reserve_buffer(std::size_t size = MSGPACK_UNPACKER_RESERVE_SIZE);
char* buffer();
std::size_t buffer_capacity() const;
void buffer_consumed(std::size_t size);
MSGPACK_DEPRECATED("please use reference version instead")
bool next(msgpack::object_handle* result);
bool next(msgpack::object_handle& result, bool& referenced);
bool next(msgpack::object_handle& result);
std::size_t message_size() const;
bool execute();
msgpack::object const& data();
msgpack::zone* release_zone();
void reset_zone();
void reset();
public:
std::size_t parsed_size() const;
char* nonparsed_buffer();
std::size_t nonparsed_size() const;
void skip_nonparsed_buffer(std::size_t size);
void remove_nonparsed_buffer();
private:
void expand_buffer(std::size_t size);
int execute_imp();
bool flush_zone();
static bool default_reference_func(msgpack::type::object_type type, std::size_t len, void*);
private:
char* m_buffer;
std::size_t m_used;
std::size_t m_free;
std::size_t m_off;
std::size_t m_parsed;
msgpack::unique_ptr<msgpack::zone> m_z;
std::size_t m_initial_buffer_size;
detail::context m_ctx;
#if defined(MSGPACK_USE_CPP03)
private:
unpacker(const unpacker&);
unpacker& operator=(const unpacker&);
#else // defined(MSGPACK_USE_CPP03)
unpacker(const unpacker&) = delete;
unpacker& operator=(const unpacker&) = delete;
#endif // defined(MSGPACK_USE_CPP03)
};
inline unpacker::unpacker(unpack_reference_func f,
void* user_data,
std::size_t initial_buffer_size,
unpack_limit const& limit)
:m_z(new msgpack::zone), m_ctx(f, user_data, limit)
{
if(initial_buffer_size < COUNTER_SIZE) {
initial_buffer_size = COUNTER_SIZE;
}
char* buffer = static_cast<char*>(::malloc(initial_buffer_size));
if(!buffer) {
throw std::bad_alloc();
}
m_buffer = buffer;
m_used = COUNTER_SIZE;
m_free = initial_buffer_size - m_used;
m_off = COUNTER_SIZE;
m_parsed = 0;
m_initial_buffer_size = initial_buffer_size;
detail::init_count(m_buffer);
m_ctx.init();
m_ctx.user().set_zone(*m_z);
m_ctx.user().set_referenced(false);
}
#if !defined(MSGPACK_USE_CPP03)
// Move constructor and move assignment operator
inline unpacker::unpacker(unpacker&& other)
:m_buffer(other.m_buffer),
m_used(other.m_used),
m_free(other.m_free),
m_off(other.m_off),
m_parsed(other.m_parsed),
m_z(std::move(other.m_z)),
m_initial_buffer_size(other.m_initial_buffer_size),
m_ctx(other.m_ctx) {
other.m_buffer = MSGPACK_NULLPTR;
}
inline unpacker& unpacker::operator=(unpacker&& other) {
this->~unpacker();
new (this) unpacker(std::move(other));
return *this;
}
#endif // !defined(MSGPACK_USE_CPP03)
inline unpacker::~unpacker()
{
// These checks are required for move operations.
if (m_buffer) detail::decr_count(m_buffer);
}
inline void unpacker::reserve_buffer(std::size_t size)
{
if(m_free >= size) return;
expand_buffer(size);
}
inline void unpacker::expand_buffer(std::size_t size)
{
if(m_used == m_off && detail::get_count(m_buffer) == 1
&& !m_ctx.user().referenced()) {
// rewind buffer
m_free += m_used - COUNTER_SIZE;
m_used = COUNTER_SIZE;
m_off = COUNTER_SIZE;
if(m_free >= size) return;
}
if(m_off == COUNTER_SIZE) {
std::size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE
while(next_size < size + m_used) {
std::size_t tmp_next_size = next_size * 2;
if (tmp_next_size <= next_size) {
next_size = size + m_used;
break;
}
next_size = tmp_next_size;
}
char* tmp = static_cast<char*>(::realloc(m_buffer, next_size));
if(!tmp) {
throw std::bad_alloc();
}
m_buffer = tmp;
m_free = next_size - m_used;
} else {
std::size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE
std::size_t not_parsed = m_used - m_off;
while(next_size < size + not_parsed + COUNTER_SIZE) {
std::size_t tmp_next_size = next_size * 2;
if (tmp_next_size <= next_size) {
next_size = size + not_parsed + COUNTER_SIZE;
break;
}
next_size = tmp_next_size;
}
char* tmp = static_cast<char*>(::malloc(next_size));
if(!tmp) {
throw std::bad_alloc();
}
detail::init_count(tmp);
std::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed);
if(m_ctx.user().referenced()) {
try {
m_z->push_finalizer(&detail::decr_count, m_buffer);
}
catch (...) {
::free(tmp);
throw;
}
m_ctx.user().set_referenced(false);
} else {
detail::decr_count(m_buffer);
}
m_buffer = tmp;
m_used = not_parsed + COUNTER_SIZE;
m_free = next_size - m_used;
m_off = COUNTER_SIZE;
}
}
inline char* unpacker::buffer()
{
return m_buffer + m_used;
}
inline std::size_t unpacker::buffer_capacity() const
{
return m_free;
}
inline void unpacker::buffer_consumed(std::size_t size)
{
m_used += size;
m_free -= size;
}
inline bool unpacker::next(msgpack::object_handle& result, bool& referenced)
{
referenced = false;
int ret = execute_imp();
if(ret < 0) {
throw msgpack::parse_error("parse error");
}
if(ret == 0) {
result.zone().reset();
result.set(msgpack::object());
return false;
} else {
referenced = m_ctx.user().referenced();
result.zone().reset( release_zone() );
result.set(data());
reset();
return true;
}
}
inline bool unpacker::next(msgpack::object_handle& result)
{
bool referenced;
return next(result, referenced);
}
inline bool unpacker::next(msgpack::object_handle* result)
{
return next(*result);
}
inline bool unpacker::execute()
{
int ret = execute_imp();
if(ret < 0) {
throw msgpack::parse_error("parse error");
} else if(ret == 0) {
return false;
} else {
return true;
}
}
inline int unpacker::execute_imp()
{
std::size_t off = m_off;
int ret = m_ctx.execute(m_buffer, m_used, m_off);
if(m_off > off) {
m_parsed += m_off - off;
}
return ret;
}
inline msgpack::object const& unpacker::data()
{
return m_ctx.data();
}
inline msgpack::zone* unpacker::release_zone()
{
if(!flush_zone()) {
return MSGPACK_NULLPTR;
}
msgpack::zone* r = new msgpack::zone;
msgpack::zone* old = m_z.release();
m_z.reset(r);
m_ctx.user().set_zone(*m_z);
return old;
}
inline void unpacker::reset_zone()
{
m_z->clear();
}
inline bool unpacker::flush_zone()
{
if(m_ctx.user().referenced()) {
try {
m_z->push_finalizer(&detail::decr_count, m_buffer);
} catch (...) {
return false;
}
m_ctx.user().set_referenced(false);
detail::incr_count(m_buffer);
}
return true;
}
inline void unpacker::reset()
{
m_ctx.init();
// don't reset referenced flag
m_parsed = 0;
}
inline std::size_t unpacker::message_size() const
{
return m_parsed - m_off + m_used;
}
inline std::size_t unpacker::parsed_size() const
{
return m_parsed;
}
inline char* unpacker::nonparsed_buffer()
{
return m_buffer + m_off;
}
inline std::size_t unpacker::nonparsed_size() const
{
return m_used - m_off;
}
inline void unpacker::skip_nonparsed_buffer(std::size_t size)
{
m_off += size;
}
inline void unpacker::remove_nonparsed_buffer()
{
m_used = m_off;
}
namespace detail {
inline parse_return
unpack_imp(const char* data, std::size_t len, std::size_t& off,
msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
unpack_reference_func f = MSGPACK_NULLPTR, void* user_data = MSGPACK_NULLPTR,
unpack_limit const& limit = unpack_limit())
{
std::size_t noff = off;
if(len <= noff) {
// FIXME
return PARSE_CONTINUE;
}
detail::context ctx(f, user_data, limit);
ctx.init();
ctx.user().set_zone(result_zone);
ctx.user().set_referenced(false);
referenced = false;
int e = ctx.execute(data, len, noff);
if(e < 0) {
return PARSE_PARSE_ERROR;
}
referenced = ctx.user().referenced();
off = noff;
if(e == 0) {
return PARSE_CONTINUE;
}
result = ctx.data();
if(noff < len) {
return PARSE_EXTRA_BYTES;
}
return PARSE_SUCCESS;
}
} // detail
// reference version
inline msgpack::object_handle unpack(
const char* data, std::size_t len, std::size_t& off, bool& referenced,
unpack_reference_func f, void* user_data,
unpack_limit const& limit
)
{
msgpack::object obj;
msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
referenced = false;
std::size_t noff = off;
parse_return ret = detail::unpack_imp(
data, len, noff, *z, obj, referenced, f, user_data, limit);
switch(ret) {
case PARSE_SUCCESS:
off = noff;
return msgpack::object_handle(obj, msgpack::move(z));
case PARSE_EXTRA_BYTES:
off = noff;
return msgpack::object_handle(obj, msgpack::move(z));
case PARSE_CONTINUE:
throw msgpack::insufficient_bytes("insufficient bytes");
case PARSE_PARSE_ERROR:
default:
throw msgpack::parse_error("parse error");
}
return msgpack::object_handle();
}
inline msgpack::object_handle unpack(
const char* data, std::size_t len, std::size_t& off,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
bool referenced;
return unpack(data, len, off, referenced, f, user_data, limit);
}
inline msgpack::object_handle unpack(
const char* data, std::size_t len, bool& referenced,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
std::size_t off = 0;
return unpack(data, len, off, referenced, f, user_data, limit);
}
inline msgpack::object_handle unpack(
const char* data, std::size_t len,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
bool referenced;
std::size_t off = 0;
return unpack(data, len, off, referenced, f, user_data, limit);
}
inline void unpack(
msgpack::object_handle& result,
const char* data, std::size_t len, std::size_t& off, bool& referenced,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
msgpack::object obj;
msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
referenced = false;
std::size_t noff = off;
parse_return ret = detail::unpack_imp(
data, len, noff, *z, obj, referenced, f, user_data, limit);
switch(ret) {
case PARSE_SUCCESS:
off = noff;
result.set(obj);
result.zone() = msgpack::move(z);
return;
case PARSE_EXTRA_BYTES:
off = noff;
result.set(obj);
result.zone() = msgpack::move(z);
return;
case PARSE_CONTINUE:
throw msgpack::insufficient_bytes("insufficient bytes");
case PARSE_PARSE_ERROR:
default:
throw msgpack::parse_error("parse error");
}
}
inline void unpack(
msgpack::object_handle& result,
const char* data, std::size_t len, std::size_t& off,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
bool referenced;
unpack(result, data, len, off, referenced, f, user_data, limit);
}
inline void unpack(
msgpack::object_handle& result,
const char* data, std::size_t len, bool& referenced,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
std::size_t off = 0;
unpack(result, data, len, off, referenced, f, user_data, limit);
}
inline void unpack(
msgpack::object_handle& result,
const char* data, std::size_t len,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
bool referenced;
std::size_t off = 0;
unpack(result, data, len, off, referenced, f, user_data, limit);
}
inline msgpack::object unpack(
msgpack::zone& z,
const char* data, std::size_t len, std::size_t& off, bool& referenced,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
msgpack::object obj;
std::size_t noff = off;
referenced = false;
parse_return ret = detail::unpack_imp(
data, len, noff, z, obj, referenced, f, user_data, limit);
switch(ret) {
case PARSE_SUCCESS:
off = noff;
return obj;
case PARSE_EXTRA_BYTES:
off = noff;
return obj;
case PARSE_CONTINUE:
throw msgpack::insufficient_bytes("insufficient bytes");
case PARSE_PARSE_ERROR:
default:
throw msgpack::parse_error("parse error");
}
return obj;
}
inline msgpack::object unpack(
msgpack::zone& z,
const char* data, std::size_t len, std::size_t& off,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
bool referenced;
return unpack(z, data, len, off, referenced, f, user_data, limit);
}
inline msgpack::object unpack(
msgpack::zone& z,
const char* data, std::size_t len, bool& referenced,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
std::size_t off = 0;
return unpack(z, data, len, off, referenced, f, user_data, limit);
}
inline msgpack::object unpack(
msgpack::zone& z,
const char* data, std::size_t len,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
bool referenced;
std::size_t off = 0;
return unpack(z, data, len, off, referenced, f, user_data, limit);
}
// obsolete
// pointer version
MSGPACK_DEPRECATED("please use reference version instead")
inline void unpack(
msgpack::object_handle* result,
const char* data, std::size_t len, std::size_t* off, bool* referenced,
unpack_reference_func f, void* user_data,
unpack_limit const& limit)
{
if (off)
if (referenced) unpack(*result, data, len, *off, *referenced, f, user_data, limit);
else unpack(*result, data, len, *off, f, user_data, limit);
else
if (referenced) unpack(*result, data, len, *referenced, f, user_data, limit);
else unpack(*result, data, len, f, user_data, limit);
}
inline bool unpacker::default_reference_func(msgpack::type::object_type /*type*/, std::size_t /*len*/, void*)
{
return true;
}
} // MSGPACK_API_VERSION_NAMESPACE(v1)
} // namespace msgpack
#endif // MSGPACK_V1_UNPACK_HPP
msgpack::detail::value< fix_tag >::type
uint32_t type
Definition: unpack.hpp:275
msgpack::type::STR
Definition: object_fwd_decl.hpp:39
msgpack::detail::unpack_user
Definition: unpack.hpp:44
msgpack::detail::unpack_array
Definition: unpack.hpp:111
msgpack::detail::unpack_array::operator()
void operator()(unpack_user &u, uint32_t n, msgpack::object &o) const
Definition: unpack.hpp:112
msgpack::unpacker::nonparsed_buffer
char * nonparsed_buffer()
Get the address that is not parsed in the buffer.
Definition: unpack.hpp:1315
msgpack::detail::unpack_map
Definition: unpack.hpp:133
msgpack::detail::unpack_int8
void unpack_int8(int8_t d, msgpack::object &o)
Definition: unpack.hpp:80
msgpack::object_map::ptr
msgpack::object_kv * ptr
Definition: object_fwd.hpp:29
msgpack::detail::incr_count
void incr_count(void *buffer)
Definition: unpack.hpp:248
msgpack::unpack_limit
Definition: unpack_decl.hpp:87
msgpack::str_size_overflow
Definition: unpack_exception.hpp:79
msgpack::object_array::size
uint32_t size
Definition: object_fwd.hpp:23
msgpack::unpack_limit::bin
std::size_t bin() const
Definition: unpack_decl.hpp:105
msgpack::detail::unpack_user::set_referenced
void set_referenced(bool referenced)
Definition: unpack.hpp:54
msgpack::unpack_limit::ext
std::size_t ext() const
Definition: unpack_decl.hpp:106
msgpack::zone::allocate_align
void * allocate_align(size_t size, size_t align=MSGPACK_ZONE_ALIGN)
Definition: cpp03_zone.hpp:246
msgpack::unpacker::~unpacker
~unpacker()
Definition: unpack.hpp:1101
msgpack::detail::unpack_map::operator()
void operator()(unpack_user &u, uint32_t n, msgpack::object &o) const
Definition: unpack.hpp:134
msgpack::type::FLOAT32
Definition: object_fwd_decl.hpp:33
msgpack::type::BOOLEAN
Definition: object_fwd_decl.hpp:30
msgpack::object_bin::ptr
const char * ptr
Definition: object_fwd.hpp:39
MSGPACK_UNPACKER_INIT_BUFFER_SIZE
#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE
Definition: unpack_decl.hpp:43
msgpack::detail::unpack_ext
void unpack_ext(unpack_user &u, const char *p, std::size_t l, msgpack::object &o)
Definition: unpack.hpp:190
msgpack::parse_return
parse_return
Definition: parse_return.hpp:23
msgpack::detail::unpack_imp
parse_return unpack_imp(const char *data, std::size_t len, std::size_t &off, msgpack::zone &result_zone, msgpack::object &result, bool &referenced, unpack_reference_func f=MSGPACK_NULLPTR, void *user_data=MSGPACK_NULLPTR, unpack_limit const &limit=unpack_limit())
Definition: unpack.hpp:1338
msgpack::detail::unpack_stack::set_container_type
void set_container_type(uint32_t container_type)
Definition: unpack.hpp:216
msgpack::detail::unpack_stack::container_type
uint32_t container_type() const
Definition: unpack.hpp:215
msgpack::detail::unpack_uint32
void unpack_uint32(uint32_t d, msgpack::object &o)
Definition: unpack.hpp:74
msgpack::unpack_limit::map
std::size_t map() const
Definition: unpack_decl.hpp:103
msgpack::unpacker::nonparsed_size
std::size_t nonparsed_size() const
Get the size of the buffer that is not parsed.
Definition: unpack.hpp:1320
msgpack::object_handle::set
void set(msgpack::object const &obj)
Definition: object.hpp:64
msgpack::detail::context::init
void init()
Definition: unpack.hpp:312
msgpack::PARSE_PARSE_ERROR
Definition: parse_return.hpp:27
msgpack::object::via
union_type via
Definition: object_fwd.hpp:93
msgpack::detail::unpack_stack::count
std::size_t count() const
Definition: unpack.hpp:212
msgpack::detail::unpack_str
void unpack_str(unpack_user &u, const char *p, uint32_t l, msgpack::object &o)
Definition: unpack.hpp:158
msgpack::unpacker::execute
bool execute()
Definition: unpack.hpp:1236
msgpack::unpack_reference_func
bool(* unpack_reference_func)(msgpack::type::object_type type, std::size_t size, void *user_data)
The type of reference or copy judging function.
Definition: unpack_decl.hpp:74
msgpack::type::BIN
Definition: object_fwd_decl.hpp:40
object.hpp
msgpack::depth_size_overflow
Definition: unpack_exception.hpp:106
msgpack::detail::unpack_int16
void unpack_int16(int16_t d, msgpack::object &o)
Definition: unpack.hpp:84
msgpack::detail::unpack_bin
void unpack_bin(unpack_user &u, const char *p, uint32_t l, msgpack::object &o)
Definition: unpack.hpp:174
msgpack::object_ext::ptr
const char * ptr
Definition: object_fwd.hpp:46
msgpack::detail::context::user
unpack_user const & user() const
Definition: unpack.hpp:330
msgpack::object_array::ptr
msgpack::object * ptr
Definition: object_fwd.hpp:24
msgpack::detail::unpack_uint8
void unpack_uint8(uint8_t d, msgpack::object &o)
Definition: unpack.hpp:68
msgpack::detail::unpack_user::zone
msgpack::zone const & zone() const
Definition: unpack.hpp:50
msgpack::object_kv::val
msgpack::object val
Definition: object.hpp:32
msgpack::detail::context::context
context(unpack_reference_func f, void *user_data, unpack_limit const &limit)
Definition: unpack.hpp:305
msgpack::object_bin::size
uint32_t size
Definition: object_fwd.hpp:38
msgpack::detail::value::type
T type
Definition: unpack.hpp:271
msgpack
Definition: adaptor_base.hpp:15
msgpack::parse_error
Definition: unpack_exception.hpp:34
msgpack::ext_size_overflow
Definition: unpack_exception.hpp:97
versioning.hpp
msgpack::object_str::ptr
const char * ptr
Definition: object_fwd.hpp:34
msgpack::unpacker::parsed_size
std::size_t parsed_size() const
Get parsed message size.
Definition: unpack.hpp:1310
msgpack::zone
Definition: cpp03_zone.hpp:22
msgpack::unpacker::unpacker
unpacker(unpack_reference_func f=&unpacker::default_reference_func, void *user_data=MSGPACK_NULLPTR, std::size_t initial_buffer_size=MSGPACK_UNPACKER_INIT_BUFFER_SIZE, unpack_limit const &limit=unpack_limit())
Constructor.
Definition: unpack.hpp:1048
msgpack::detail::unpack_false
void unpack_false(msgpack::object &o)
Definition: unpack.hpp:108
msgpack::type::object_type
object_type
Definition: object_fwd_decl.hpp:28
msgpack::object::union_type::boolean
bool boolean
Definition: object_fwd.hpp:77
msgpack::unpack
msgpack::object_handle unpack(const char *data, std::size_t len, std::size_t &off, bool &referenced, unpack_reference_func f, void *user_data, unpack_limit const &limit)
Unpack msgpack::object from a buffer.
Definition: unpack.hpp:1382
msgpack::detail::unpack_stack::set_obj
void set_obj(msgpack::object const &obj)
Definition: unpack.hpp:211
msgpack::object_kv
Definition: object.hpp:30
msgpack::unique_ptr< msgpack::zone >
msgpack::unpacker::remove_nonparsed_buffer
void remove_nonparsed_buffer()
Remove nonparsed buffer and reset the current position as a new start point.
Definition: unpack.hpp:1330
msgpack::type::NIL
Definition: object_fwd_decl.hpp:29
cpp_config.hpp
msgpack::object::union_type::i64
int64_t i64
Definition: object_fwd.hpp:79
msgpack::type::NEGATIVE_INTEGER
Definition: object_fwd_decl.hpp:32
msgpack::unpacker::reserve_buffer
void reserve_buffer(std::size_t size=MSGPACK_UNPACKER_RESERVE_SIZE)
Reserve a buffer memory.
Definition: unpack.hpp:1108
msgpack::detail::context
Definition: unpack.hpp:303
msgpack::detail::unpack_float
void unpack_float(float d, msgpack::object &o)
Definition: unpack.hpp:96
msgpack::bin_size_overflow
Definition: unpack_exception.hpp:88
msgpack::detail::init_count
void init_count(void *buffer)
Definition: unpack.hpp:226
zone.hpp
msgpack::detail::unpack_double
void unpack_double(double d, msgpack::object &o)
Definition: unpack.hpp:99
msgpack::detail::unpack_user::reference_func
unpack_reference_func reference_func() const
Definition: unpack.hpp:55
msgpack::detail::unpack_stack::obj
msgpack::object & obj()
Definition: unpack.hpp:210
msgpack::detail::unpack_uint64
void unpack_uint64(uint64_t d, msgpack::object &o)
Definition: unpack.hpp:77
msgpack::PARSE_CONTINUE
Definition: parse_return.hpp:26
msgpack::object_ext::size
uint32_t size
Definition: object_fwd.hpp:45
msgpack::insufficient_bytes
Definition: unpack_exception.hpp:43
msgpack::detail::load
msgpack::enable_if< sizeof(T)==sizeof(fix_tag)>::type load(uint32_t &dst, const char *n)
Definition: unpack.hpp:279
msgpack::array_size_overflow
Definition: unpack_exception.hpp:61
msgpack::unpacker::reset_zone
void reset_zone()
Definition: unpack.hpp:1277
msgpack::detail::unpack_user::limit
unpack_limit const & limit() const
Definition: unpack.hpp:57
msgpack::type::size
std::size_t size(T const &t)
Definition: size_equal_only.hpp:24
msgpack::unpacker::release_zone
msgpack::zone * release_zone()
Definition: unpack.hpp:1263
msgpack::detail::unpack_int64
void unpack_int64(int64_t d, msgpack::object &o)
Definition: unpack.hpp:92
msgpack::unpack_limit::str
std::size_t str() const
Definition: unpack_decl.hpp:104
msgpack::detail::unpack_uint16
void unpack_uint16(uint16_t d, msgpack::object &o)
Definition: unpack.hpp:71
msgpack::detail::unpack_true
void unpack_true(msgpack::object &o)
Definition: unpack.hpp:105
msgpack::detail::unpack_stack::set_map_key
void set_map_key(msgpack::object const &map_key)
Definition: unpack.hpp:218
msgpack::unpacker::buffer_consumed
void buffer_consumed(std::size_t size)
Notify a buffer consumed information to msgpack::unpacker.
Definition: unpack.hpp:1196
msgpack::object::union_type::f64
double f64
Definition: object_fwd.hpp:84
msgpack::unpacker::data
msgpack::object const & data()
Definition: unpack.hpp:1258
msgpack::type::EXT
Definition: object_fwd_decl.hpp:43
msgpack::object::union_type::array
msgpack::object_array array
Definition: object_fwd.hpp:85
msgpack::unpacker::buffer
char * buffer()
Get buffer pointer.
Definition: unpack.hpp:1186
unpack_decl.hpp
COUNTER_SIZE
const size_t COUNTER_SIZE
Definition: unpack_decl.hpp:40
msgpack::detail::unpack_user::unpack_user
unpack_user(unpack_reference_func f=MSGPACK_NULLPTR, void *user_data=MSGPACK_NULLPTR, unpack_limit const &limit=unpack_limit())
Definition: unpack.hpp:46
msgpack::enable_if
Definition: cpp_config_decl.hpp:56
msgpack::object::union_type::map
msgpack::object_map map
Definition: object_fwd.hpp:86
msgpack::detail::get_count
std::atomic< unsigned int > const & get_count(void *buffer)
Definition: unpack.hpp:263
msgpack::object::union_type::str
msgpack::object_str str
Definition: object_fwd.hpp:87
msgpack::unpack_limit::array
std::size_t array() const
Definition: unpack_decl.hpp:102
msgpack::object
Object class that corresponding to MessagePack format object.
Definition: object_fwd.hpp:75
msgpack::map_size_overflow
Definition: unpack_exception.hpp:70
msgpack::unpacker::message_size
std::size_t message_size() const
Get message size.
Definition: unpack.hpp:1305
msgpack::object::type
msgpack::type::object_type type
Definition: object_fwd.hpp:92
msgpack::detail::unpack_stack::map_key
msgpack::object const & map_key() const
Definition: unpack.hpp:217
msgpack::detail::unpack_stack
Definition: unpack.hpp:207
MSGPACK_API_VERSION_NAMESPACE
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
msgpack::type::ARRAY
Definition: object_fwd_decl.hpp:41
msgpack::unpacker::reset
void reset()
Definition: unpack.hpp:1298
msgpack::unpacker::operator=
unpacker & operator=(unpacker &&other)
Definition: unpack.hpp:1092
msgpack::PARSE_SUCCESS
Definition: parse_return.hpp:24
msgpack::object_kv::key
msgpack::object key
Definition: object.hpp:31
msgpack::PARSE_EXTRA_BYTES
Definition: parse_return.hpp:25
msgpack::object_map::size
uint32_t size
Definition: object_fwd.hpp:28
msgpack::type::MAP
Definition: object_fwd_decl.hpp:42
msgpack::detail::context::data
msgpack::object const & data() const
Definition: unpack.hpp:320
msgpack::object_handle::zone
msgpack::unique_ptr< msgpack::zone > & zone()
Get unique_ptr reference of zone.
Definition: object.hpp:90
msgpack::type::FLOAT64
Definition: object_fwd_decl.hpp:34
unpack_exception.hpp
msgpack::detail::unpack_stack::set_count
void set_count(std::size_t count)
Definition: unpack.hpp:213
msgpack::object_str::size
uint32_t size
Definition: object_fwd.hpp:33
MSGPACK_ZONE_ALIGNOF
#define MSGPACK_ZONE_ALIGNOF(type)
Definition: cpp03_zone_decl.hpp:30
msgpack::detail::unpack_nil
void unpack_nil(msgpack::object &o)
Definition: unpack.hpp:102
msgpack::detail::unpack_user::zone
msgpack::zone & zone()
Definition: unpack.hpp:51
msgpack::detail::unpack_map_item
void unpack_map_item(msgpack::object &c, msgpack::object const &k, msgpack::object const &v)
Definition: unpack.hpp:146
msgpack::detail::decr_count
void decr_count(void *buffer)
Definition: unpack.hpp:235
msgpack::unpacker
Unpacking class for a stream deserialization.
Definition: unpack.hpp:847
msgpack::detail::fix_tag
Definition: unpack_decl.hpp:180
msgpack::unpacker::buffer_capacity
std::size_t buffer_capacity() const
Get buffer capacity.
Definition: unpack.hpp:1191
msgpack::detail::unpack_int32
void unpack_int32(int32_t d, msgpack::object &o)
Definition: unpack.hpp:88
msgpack::detail::unpack_user::limit
unpack_limit & limit()
Definition: unpack.hpp:58
MSGPACK_NULLPTR
#define MSGPACK_NULLPTR
Definition: cpp_config_decl.hpp:35
msgpack::detail::unpack_array_item
void unpack_array_item(msgpack::object &c, msgpack::object const &o)
Definition: unpack.hpp:124
msgpack::move
T & move(T &t)
msgpack::detail::unpack_user::user_data
void * user_data() const
Definition: unpack.hpp:56
msgpack::detail::unpack_user::set_zone
void set_zone(msgpack::zone &zone)
Definition: unpack.hpp:52
msgpack::object::union_type::ext
msgpack::object_ext ext
Definition: object_fwd.hpp:89
msgpack::detail::value
Definition: unpack.hpp:270
msgpack::detail::unpack_stack::decr_count
std::size_t decr_count()
Definition: unpack.hpp:214
msgpack::detail::unpack_stack::obj
msgpack::object const & obj() const
Definition: unpack.hpp:209
msgpack::unpacker::skip_nonparsed_buffer
void skip_nonparsed_buffer(std::size_t size)
Skip the specified size of non-parsed buffer.
Definition: unpack.hpp:1325
msgpack::unpacker::next
bool next(msgpack::object_handle *result)
Unpack one msgpack::object. [obsolete].
Definition: unpack.hpp:1230
MSGPACK_DEPRECATED
#define MSGPACK_DEPRECATED(msg)
Definition: cpp_config.hpp:132
msgpack::object_handle
The class holds object and zone.
Definition: object.hpp:44
msgpack::detail::context::user
unpack_user & user()
Definition: unpack.hpp:325
msgpack::detail::context::execute
int execute(const char *data, std::size_t len, std::size_t &off)
Definition: unpack.hpp:452
msgpack::detail::unpack_user::referenced
bool referenced() const
Definition: unpack.hpp:53
msgpack::type::POSITIVE_INTEGER
Definition: object_fwd_decl.hpp:31
msgpack::object::union_type::u64
uint64_t u64
Definition: object_fwd.hpp:78
msgpack::object::union_type::bin
msgpack::object_bin bin
Definition: object_fwd.hpp:88
MSGPACK_UNPACKER_RESERVE_SIZE
#define MSGPACK_UNPACKER_RESERVE_SIZE
Definition: unpack_decl.hpp:47