generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-04-23 08:52:32 +02:00
Code Issues Projects Releases Wiki Activity
msgpack/include/msgpack/unpack.hpp
Takatoshi Kondo 09325ed846 Re-implemented msgpack::unpacker's move operations. 
I refered to the following article and comments.
http://scottmeyers.blogspot.jp/2014/06/the-drawbacks-of-implementing-move.html

msgpack::detail::context back to copiable.
msgpack::detail::context doen't have any resource ownership, so there is
no strong reason to avoid copy.
2014-07-24 10:38:24 +09:00

1304 lines
37 KiB
C++
Raw Blame History

//
// MessagePack for C++ deserializing routine
//
// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef MSGPACK_UNPACK_HPP
#define MSGPACK_UNPACK_HPP
#include "object.hpp"
#include "zone.hpp"
#include "unpack_define.h"
#include "cpp_config.hpp"
#include <memory>
#include <stdexcept>
#include <byteswap.h>
#define COUNTER_SIZE (sizeof(_msgpack_atomic_counter_t))
#ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE
#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024)
#endif
#ifndef MSGPACK_UNPACKER_RESERVE_SIZE
#define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024)
#endif
// backward compatibility
#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE
#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE
#endif
namespace msgpack {
namespace detail {
class unpack_user {
public:
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; }
private:
msgpack::zone* m_zone;
bool m_referenced;
};
inline void unpack_uint8(uint8_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_uint16(uint16_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_uint32(uint32_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_uint64(uint64_t d, object& o)
{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
inline void unpack_int8(int8_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_int16(int16_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_int32(int32_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_int64(int64_t d, object& o)
{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; }
else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } }
inline void unpack_float(float d, object& o)
{ o.type = type::DOUBLE; o.via.dec = d; }
inline void unpack_double(double d, object& o)
{ o.type = type::DOUBLE; o.via.dec = d; }
inline void unpack_nil(object& o)
{ o.type = type::NIL; }
inline void unpack_true(object& o)
{ o.type = type::BOOLEAN; o.via.boolean = true; }
inline void unpack_false(object& o)
{ o.type = type::BOOLEAN; o.via.boolean = false; }
struct unpack_array {
bool operator()(unpack_user&u, unsigned int n, object& o) const {
o.type = type::ARRAY;
o.via.array.size = 0;
o.via.array.ptr = static_cast<object*>(u.zone().allocate_align(n*sizeof(object)));
if(o.via.array.ptr == nullptr) { return false; }
return true;
}
};
inline void unpack_array_item(object& c, object const& o)
{
#if defined(__GNUC__) && !defined(__clang__)
memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object));
#else /* __GNUC__ && !__clang__ */
c.via.array.ptr[c.via.array.size++] = o;
#endif /* __GNUC__ && !__clang__ */
}
struct unpack_map {
bool operator()(unpack_user& u, unsigned int n, object& o) const {
o.type = type::MAP;
o.via.map.size = 0;
o.via.map.ptr = static_cast<object_kv*>(u.zone().allocate_align(n*sizeof(object_kv)));
if(o.via.map.ptr == nullptr) { return false; }
return true;
}
};
inline void unpack_map_item(object& c, object const& k, object const& v)
{
#if defined(__GNUC__) && !defined(__clang__)
memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object));
memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(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* b, const char* p, unsigned int l, object& o)
{
o.type = type::STR;
o.via.str.ptr = p;
o.via.str.size = l;
u.set_referenced(true);
}
inline void unpack_bin(unpack_user& u, const char* b, const char* p, unsigned int l, object& o)
{
o.type = type::BIN;
o.via.bin.ptr = p;
o.via.bin.size = l;
u.set_referenced(true);
}
class unpack_stack {
public:
object const& obj() const { return m_obj; }
object& obj() { return m_obj; }
void set_obj(object const& obj) { m_obj = obj; }
size_t count() const { return m_count; }
void set_count(size_t count) { m_count = count; }
size_t decl_count() { return --m_count; }
unsigned int container_type() const { return m_container_type; }
void set_container_type(unsigned int container_type) { m_container_type = container_type; }
object const& map_key() const { return m_map_key; }
void set_map_key(object const& map_key) { m_map_key = map_key; }
private:
object m_obj;
size_t m_count;
unsigned int m_container_type;
object m_map_key;
};
inline void init_count(void* buffer)
{
*reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer) = 1;
}
inline void decl_count(void* buffer)
{
if(_msgpack_sync_decr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer)) == 0) {
free(buffer);
}
}
inline void incr_count(void* buffer)
{
_msgpack_sync_incr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer));
}
inline _msgpack_atomic_counter_t get_count(void* buffer)
{
return *reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer);
}
struct fix_tag {
char f1[65]; // FIXME unique size is required. or use is_same meta function.
};
template <typename T>
struct value {
typedef T type;
};
template <>
struct value<fix_tag> {
typedef unsigned int type;
};
template <typename T>
inline void load(unsigned int& dst, const char* n, typename msgpack::enable_if<sizeof(T) == sizeof(fix_tag)>::type* = nullptr) {
dst = static_cast<unsigned int>(*reinterpret_cast<const uint8_t*>(n)) & 0x0f;
}
template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 1>::type* = nullptr) {
dst = static_cast<T>(*reinterpret_cast<const uint8_t*>(n));
}
template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 2>::type* = nullptr) {
_msgpack_load16(T, n, &dst);
}
template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 4>::type* = nullptr) {
_msgpack_load32(T, n, &dst);
}
template <typename T>
inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 8>::type* = nullptr) {
_msgpack_load64(T, n, &dst);
}
class context {
public:
context():m_trail(0), m_cs(CS_HEADER), m_top(0)
{
m_stack[0].set_obj(object());
}
void init()
{
m_cs = CS_HEADER;
m_trail = 0;
m_top = 0;
m_stack[0].set_obj(object());
}
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, size_t len, size_t& off)
{
assert(len >= off);
m_start = data;
m_current = data + off;
m_stack_idx = 0;
const char* const pe = data + len;
const char* n = nullptr;
object obj;
if(m_current == pe) {
off = m_current - m_start;
return 0;
}
bool fixed_trail_again = false;
do {
if (m_cs == CS_HEADER) {
fixed_trail_again = false;
int selector = *reinterpret_cast<const unsigned char*>(m_current);
if (0) {
} else 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(0xc0 <= selector && selector <= 0xdf) { // Variable
switch(selector) {
case 0xc0: { // nil
unpack_nil(obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
//case 0xc1: // string
case 0xc2: { // false
unpack_false(obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case 0xc3: { // true
unpack_true(obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case 0xc4: // bin 8
case 0xc5: // bin 16
case 0xc6: // bin 32
m_trail = 1 << (static_cast<unsigned int>(*m_current) & 0x03);
m_cs = next_cs(m_current);
fixed_trail_again = true;
break;
//case 0xc7:
//case 0xc8:
//case 0xc9:
case 0xca: // float
case 0xcb: // double
case 0xcc: // unsigned int 8
case 0xcd: // unsigned int 16
case 0xce: // unsigned int 32
case 0xcf: // unsigned int 64
case 0xd0: // signed int 8
case 0xd1: // signed int 16
case 0xd2: // signed int 32
case 0xd3: // signed int 64
m_trail = 1 << (static_cast<unsigned int>(*m_current) & 0x03);
m_cs = next_cs(m_current);
fixed_trail_again = true;
break;
//case 0xd4:
//case 0xd5:
//case 0xd6: // big integer 16
//case 0xd7: // big integer 32
//case 0xd8: // big float 16
case 0xd9: // str 8
case 0xda: // str 16
case 0xdb: // str 32
m_trail = 1 << ((static_cast<unsigned int>(*m_current) & 0x03) - 1);
m_cs = next_cs(m_current);
fixed_trail_again = true;
break;
case 0xdc: // array 16
case 0xdd: // array 32
case 0xde: // map 16
case 0xdf: // map 32
m_trail = 2 << (static_cast<unsigned int>(*m_current) & 0x01);
m_cs = next_cs(m_current);
fixed_trail_again = true;
break;
default:
off = m_current - m_start;
return -1;
}
} else if(0xa0 <= selector && selector <= 0xbf) { // FixStr
m_trail = static_cast<unsigned int>(*m_current) & 0x1f;
if(m_trail == 0) {
unpack_str(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
fixed_trail_again = true;
}
} else if(0x90 <= selector && selector <= 0x9f) { // FixArray
int ret = push_aggregate<fix_tag>(
unpack_array(), 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(), CT_MAP_KEY, obj, m_current, off);
if (ret != 0) return ret;
} else {
off = m_current - m_start;
return -1;
}
// end CS_HEADER
}
if (m_cs != CS_HEADER || fixed_trail_again) {
if (fixed_trail_again) {
++m_current;
fixed_trail_again = false;
}
if((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 CS_
//case CS_
case 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 CS_DOUBLE: {
union { uint64_t i; double f; } mem;
load<uint64_t>(mem.i, n);
#if 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 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 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 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 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 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 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 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 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 CS_STR_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_str(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case CS_BIN_8: {
uint8_t tmp;
load<uint8_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_bin(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case CS_STR_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_str(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
fixed_trail_again = true;
}
} break;
case CS_BIN_16: {
uint16_t tmp;
load<uint16_t>(tmp, n);
m_trail = tmp;
if(m_trail == 0) {
unpack_bin(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = ACS_BIN_VALUE;
fixed_trail_again = true;
}
} break;
case CS_STR_32:
load<uint32_t>(m_trail, n);
if(m_trail == 0) {
unpack_str(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = ACS_STR_VALUE;
fixed_trail_again = true;
}
break;
case CS_BIN_32:
load<uint32_t>(m_trail, n);
if(m_trail == 0) {
unpack_bin(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_cs = ACS_BIN_VALUE;
fixed_trail_again = true;
}
break;
case ACS_STR_VALUE: {
unpack_str(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case ACS_BIN_VALUE: {
unpack_bin(m_user, data, n, m_trail, obj);
int ret = push_proc(obj, off);
if (ret != 0) return ret;
} break;
case CS_ARRAY_16: {
int ret = push_aggregate<uint16_t>(
unpack_array(), CT_ARRAY_ITEM, obj, n, off);
if (ret != 0) return ret;
} break;
case CS_ARRAY_32: {
/* FIXME security guard */
int ret = push_aggregate<uint32_t>(
unpack_array(), CT_ARRAY_ITEM, obj, n, off);
if (ret != 0) return ret;
} break;
case CS_MAP_16: {
int ret = push_aggregate<uint16_t>(
unpack_map(), CT_MAP_KEY, obj, n, off);
if (ret != 0) return ret;
} break;
case CS_MAP_32: {
/* FIXME security guard */
int ret = push_aggregate<uint32_t>(
unpack_map(), 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;
}
private:
template <typename T>
static unsigned int next_cs(T p)
{
return static_cast<unsigned int>(*p) & 0x1f;
}
template <typename T, typename Func>
int push_aggregate(
Func const& f,
unsigned int container_type,
object& obj,
const char* load_pos,
size_t& off) {
if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) {
typename value<T>::type tmp;
load<T>(tmp, load_pos);
if (f(m_user, tmp, m_stack[m_top].obj())) {
if(tmp == 0) {
obj = m_stack[m_top].obj();
int ret = push_proc(obj, off);
if (ret != 0) return ret;
}
else {
m_stack[m_top].set_container_type(container_type);
m_stack[m_top].set_count(tmp);
++m_top;
m_cs = CS_HEADER;
++m_current;
}
}
else {
off = m_current - m_start;
return -1;
}
}
else {
off = m_current - m_start;
return -1;
}
return 0;
}
int push_item(object& obj) {
bool finish = false;
while (!finish) {
if(m_top == 0) {
return 1;
}
m_stack_idx = m_top - 1;
unpack_stack* sp = &m_stack[m_stack_idx];
switch(sp->container_type()) {
case CT_ARRAY_ITEM:
unpack_array_item(sp->obj(), obj);
if(sp->decl_count() == 0) {
obj = sp->obj();
--m_top;
/*printf("stack pop %d\n", m_top);*/
}
else {
finish = true;
}
break;
case CT_MAP_KEY:
sp->set_map_key(obj);
sp->set_container_type(CT_MAP_VALUE);
finish = true;
break;
case CT_MAP_VALUE:
unpack_map_item(sp->obj(), sp->map_key(), obj);
if(sp->decl_count() == 0) {
obj = sp->obj();
--m_top;
/*printf("stack pop %d\n", m_top);*/
}
else {
sp->set_container_type(CT_MAP_KEY);
finish = true;
}
break;
default:
return -1;
}
}
return 0;
}
int push_proc(object& obj, 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 = CS_HEADER;
++m_current;
}
return ret;
}
private:
char const* m_start;
char const* m_current;
unsigned int m_trail;
unpack_user m_user;
unsigned int m_cs;
unsigned int m_top;
unsigned int m_stack_idx;
unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE];
};
} // detail
struct unpack_error : public std::runtime_error {
unpack_error(const std::string& msg) :
std::runtime_error(msg) { }
};
class unpacked {
public:
unpacked() { }
unpacked(object const& obj, msgpack::unique_ptr<msgpack::zone> z) :
m_obj(obj), m_zone(msgpack::move(z)) { }
void set(object const& obj)
{ m_obj = obj; }
const object& get() const
{ return m_obj; }
msgpack::unique_ptr<msgpack::zone>& zone()
{ return m_zone; }
const msgpack::unique_ptr<msgpack::zone>& zone() const
{ return m_zone; }
private:
object m_obj;
msgpack::unique_ptr<msgpack::zone> m_zone;
};
class unpacker {
public:
unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE);
#if !defined(MSGPACK_USE_CPP03)
unpacker(unpacker&& other);
unpacker& operator=(unpacker&& other);
#endif // !defined(MSGPACK_USE_CPP03)
~unpacker();
public:
/*! 1. reserve buffer. at least `size' bytes of capacity will be ready */
void reserve_buffer(size_t size = MSGPACK_UNPACKER_RESERVE_SIZE);
/*! 2. read data to the buffer() up to buffer_capacity() bytes */
char* buffer();
size_t buffer_capacity() const;
/*! 3. specify the number of bytes actually copied */
void buffer_consumed(size_t size);
/*! 4. repeat next() until it retunrs false */
bool next(unpacked* result);
/*! 5. check if the size of message doesn't exceed assumption. */
size_t message_size() const;
// Basic usage of the unpacker is as following:
//
// unpacker pac;
// while( /* input is readable */ ) {
//
// // 1.
// pac.reserve_buffer(32*1024);
//
// // 2.
// size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity());
//
// // error handling ...
//
// // 3.
// pac.buffer_consumed(bytes);
//
// // 4.
// unpacked result;
// while(pac.next(&result)) {
// // do some with the object with the zone.
// object obj = result.get();
// std::auto_ptr<msgpack:zone> z = result.zone();
// on_message(obj, z);
//
// //// boost::shared_ptr is also usable:
// // boost::shared_ptr<zone> life(z.release());
// // on_message(result.get(), life);
// }
//
// // 5.
// if(pac.message_size() > 10*1024*1024) {
// throw std::runtime_error("message is too large");
// }
// }
//
/*! for backward compatibility */
bool execute();
/*! for backward compatibility */
object const& data();
/*! for backward compatibility */
zone* release_zone();
/*! for backward compatibility */
void reset_zone();
/*! for backward compatibility */
void reset();
public:
// These functions are usable when non-MessagePack message follows after
// MessagePack message.
size_t parsed_size() const;
/*! get address of the buffer that is not parsed */
char* nonparsed_buffer();
size_t nonparsed_size() const;
/*! skip specified size of non-parsed buffer, leaving the buffer */
// Note that the `size' argument must be smaller than nonparsed_size()
void skip_nonparsed_buffer(size_t size);
/*! remove unparsed buffer from unpacker */
// Note that reset() leaves non-parsed buffer.
void remove_nonparsed_buffer();
private:
void expand_buffer(size_t size);
int execute_imp();
bool flush_zone();
private:
char* m_buffer;
size_t m_used;
size_t m_free;
size_t m_off;
size_t m_parsed;
zone* m_z;
size_t m_initial_buffer_size;
detail::context m_ctx;
private:
unpacker(const unpacker&);
unpacker& operator=(const unpacker&);
};
inline void unpack(unpacked& result,
const char* data, size_t len, size_t* offset = nullptr);
inline void unpack(unpacked* result,
const char* data, size_t len, size_t* offset = nullptr);
// obsolete
typedef enum {
UNPACK_SUCCESS = 2,
UNPACK_EXTRA_BYTES = 1,
UNPACK_CONTINUE = 0,
UNPACK_PARSE_ERROR = -1
} unpack_return;
// obsolete
static unpack_return unpack(const char* data, size_t len, size_t* off,
zone& z, object& result);
static unpack_return unpack(const char* data, size_t len, size_t* off,
zone* z, object* result);
// obsolete
static object unpack(const char* data, size_t len, zone& z, size_t* off = nullptr);
static object unpack(const char* data, size_t len, zone* z, size_t* off = nullptr);
inline unpacker::unpacker(size_t initial_buffer_size)
{
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();
}
zone* z = zone::create(MSGPACK_ZONE_CHUNK_SIZE);
if(!z) {
::free(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;
m_z = z;
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(other.m_z),
m_initial_buffer_size(other.m_initial_buffer_size),
m_ctx(other.m_ctx) {
other.m_buffer = nullptr;
other.m_z = 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_z) zone::destroy(m_z);
if (m_buffer) detail::decl_count(m_buffer);
}
inline void unpacker::reserve_buffer(size_t size)
{
if(m_free >= size) return;
expand_buffer(size);
}
inline void unpacker::expand_buffer(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) {
size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE
while(next_size < size + m_used) {
next_size *= 2;
}
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 {
size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE
size_t not_parsed = m_used - m_off;
while(next_size < size + not_parsed + COUNTER_SIZE) {
next_size *= 2;
}
char* tmp = static_cast<char*>(::malloc(next_size));
if(!tmp) {
throw std::bad_alloc();
}
detail::init_count(tmp);
::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed);
if(m_ctx.user().referenced()) {
try {
m_z->push_finalizer(&detail::decl_count, m_buffer);
}
catch (...) {
::free(tmp);
throw;
}
m_ctx.user().set_referenced(false);
} else {
detail::decl_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 size_t unpacker::buffer_capacity() const
{
return m_free;
}
inline void unpacker::buffer_consumed(size_t size)
{
m_used += size;
m_free -= size;
}
inline bool unpacker::next(unpacked* result)
{
int ret = execute_imp();
if(ret < 0) {
throw unpack_error("parse error");
}
if(ret == 0) {
result->zone().reset();
result->set(object());
return false;
} else {
result->zone().reset( release_zone() );
result->set(data());
reset();
return true;
}
}
inline bool unpacker::execute()
{
int ret = execute_imp();
if(ret < 0) {
throw unpack_error("parse error");
} else if(ret == 0) {
return false;
} else {
return true;
}
}
inline int unpacker::execute_imp()
{
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 object const& unpacker::data()
{
return m_ctx.data();
}
inline zone* unpacker::release_zone()
{
if(!flush_zone()) {
return nullptr;
}
zone* r = zone::create(MSGPACK_ZONE_CHUNK_SIZE);
if(!r) {
return nullptr;
}
zone* old = m_z;
m_z = 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::decl_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 size_t unpacker::message_size() const
{
return m_parsed - m_off + m_used;
}
inline size_t unpacker::parsed_size() const
{
return m_parsed;
}
inline char* unpacker::nonparsed_buffer()
{
return m_buffer + m_off;
}
inline size_t unpacker::nonparsed_size() const
{
return m_used - m_off;
}
inline void unpacker::skip_nonparsed_buffer(size_t size)
{
m_off += size;
}
inline void unpacker::remove_nonparsed_buffer()
{
m_used = m_off;
}
namespace detail {
inline unpack_return
unpack_imp(const char* data, size_t len, size_t* off,
zone& result_zone, object& result)
{
size_t noff = 0;
if(off != nullptr) { noff = *off; }
if(len <= noff) {
// FIXME
return UNPACK_CONTINUE;
}
detail::context ctx;
ctx.init();
ctx.user().set_zone(result_zone);
ctx.user().set_referenced(false);
int e = ctx.execute(data, len, noff);
if(e < 0) {
return UNPACK_PARSE_ERROR;
}
if(off != nullptr) { *off = noff; }
if(e == 0) {
return UNPACK_CONTINUE;
}
result = ctx.data();
if(noff < len) {
return UNPACK_EXTRA_BYTES;
}
return UNPACK_SUCCESS;
}
} // detail
// reference version
inline void unpack(unpacked& result,
const char* data, size_t len, size_t* offset)
{
object obj;
msgpack::unique_ptr<zone> z(new zone());
unpack_return ret = detail::unpack_imp(
data, len, offset, *z, obj);
switch(ret) {
case UNPACK_SUCCESS:
result.set(obj);
result.zone() = msgpack::move(z);
return;
case UNPACK_EXTRA_BYTES:
result.set(obj);
result.zone() = msgpack::move(z);
return;
case UNPACK_CONTINUE:
throw unpack_error("insufficient bytes");
case UNPACK_PARSE_ERROR:
default:
throw unpack_error("parse error");
}
}
// pointer version
inline void unpack(unpacked* result,
const char* data, size_t len, size_t* offset) {
unpack(*result, data, len, offset);
}
// obsolete
// reference version
inline unpack_return unpack(const char* data, size_t len, size_t* off,
zone& z, object& result)
{
return detail::unpack_imp(data, len, off,
z, result);
}
// pointer version
inline unpack_return unpack(const char* data, size_t len, size_t* off,
zone* z, object* result)
{
return unpack(data, len, off, *z, *result);
}
// obsolete
// reference version
inline object unpack(const char* data, size_t len, zone& z, size_t* off)
{
object result;
switch( unpack(data, len, off, z, result) ) {
case UNPACK_SUCCESS:
return result;
case UNPACK_EXTRA_BYTES:
if(off) {
return result;
} else {
throw unpack_error("extra bytes");
}
case UNPACK_CONTINUE:
throw unpack_error("insufficient bytes");
case UNPACK_PARSE_ERROR:
default:
throw unpack_error("parse error");
}
}
// pointer version
inline object unpack(const char* data, size_t len, zone* z, size_t* off)
{
return unpack(data, len, *z, off);
}
} // namespace msgpack
#endif /* msgpack/unpack.hpp */
Reference in New Issue View Git Blame Copy Permalink