10 #ifndef MSGPACK_UNPACK_HPP 11 #define MSGPACK_UNPACK_HPP 16 #include "unpack_define.h" 23 #if !defined(MSGPACK_USE_CPP03) 33 #endif // defined(_MSC_VER) 35 #ifdef _msgpack_atomic_counter_header 36 #include _msgpack_atomic_counter_header 42 #ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE 43 #define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024) 46 #ifndef MSGPACK_UNPACKER_RESERVE_SIZE 47 #define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024) 52 #ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE 53 #define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE 78 :std::runtime_error(msg) {}
79 #if !defined(MSGPACK_USE_CPP03) 81 std::runtime_error(msg) {}
82 #endif // !defined(MSGPACK_USE_CPP03) 88 #if !defined(MSGPACK_USE_CPP03) 91 #endif // !defined(MSGPACK_USE_CPP03) 97 #if !defined(MSGPACK_USE_CPP03) 100 #endif // !defined(MSGPACK_USE_CPP03) 106 #if !defined(MSGPACK_USE_CPP03) 115 #if !defined(MSGPACK_USE_CPP03) 124 #if !defined(MSGPACK_USE_CPP03) 133 #if !defined(MSGPACK_USE_CPP03) 142 #if !defined(MSGPACK_USE_CPP03) 151 #if !defined(MSGPACK_USE_CPP03) 160 #if !defined(MSGPACK_USE_CPP03) 169 std::size_t array = 0xffffffff,
170 std::size_t map = 0xffffffff,
171 std::size_t str = 0xffffffff,
172 std::size_t bin = 0xffffffff,
173 std::size_t ext = 0xffffffff,
174 std::size_t depth = 0xffffffff)
181 std::size_t
array()
const {
return array_; }
182 std::size_t
map()
const {
return map_; }
183 std::size_t
str()
const {
return str_; }
184 std::size_t
bin()
const {
return bin_; }
185 std::size_t
ext()
const {
return ext_; }
186 std::size_t
depth()
const {
return depth_; }
202 void* user_data =
nullptr,
204 :m_func(f), m_user_data(user_data), m_limit(limit) {}
277 #if defined(__GNUC__) && !defined(__clang__) 295 #if defined(__GNUC__) && !defined(__clang__) 315 std::memcpy(tmp, p, l);
331 std::memcpy(tmp, p, l);
347 std::memcpy(tmp, p, l);
350 o.
via.
ext.
size =
static_cast<uint32_t
>(l - 1);
359 std::size_t
count()
const {
return m_count; }
369 uint32_t m_container_type;
375 #if defined(MSGPACK_USE_CPP03) 376 *
reinterpret_cast<volatile _msgpack_atomic_counter_t*
>(buffer) = 1;
377 #else // defined(MSGPACK_USE_CPP03) 378 new (buffer) std::atomic<unsigned int>(1);
379 #endif // defined(MSGPACK_USE_CPP03) 384 #if defined(MSGPACK_USE_CPP03) 385 if(_msgpack_sync_decr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer)) == 0) {
388 #else // defined(MSGPACK_USE_CPP03) 389 if (--*
reinterpret_cast<std::atomic<unsigned int>*
>(buffer) == 0) {
392 #endif // defined(MSGPACK_USE_CPP03) 397 #if defined(MSGPACK_USE_CPP03) 398 _msgpack_sync_incr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer));
399 #else // defined(MSGPACK_USE_CPP03) 400 ++*
reinterpret_cast<std::atomic<unsigned int>*
>(buffer);
401 #endif // defined(MSGPACK_USE_CPP03) 404 #if defined(MSGPACK_USE_CPP03) 405 inline _msgpack_atomic_counter_t
get_count(
void* buffer)
407 return *
reinterpret_cast<volatile _msgpack_atomic_counter_t*
>(buffer);
409 #else // defined(MSGPACK_USE_CPP03) 410 inline std::atomic<unsigned int>
const&
get_count(
void* buffer)
412 return *
reinterpret_cast<std::atomic<unsigned int>*
>(buffer);
414 #endif // defined(MSGPACK_USE_CPP03) 420 template <
typename T>
429 template <
typename T>
431 dst =
static_cast<uint32_t
>(*
reinterpret_cast<const uint8_t*
>(n)) & 0x0f;
434 template <
typename T>
436 dst =
static_cast<T
>(*
reinterpret_cast<const uint8_t*
>(n));
439 template <
typename T>
441 _msgpack_load16(T, n, &dst);
444 template <
typename T>
446 _msgpack_load32(T, n, &dst);
449 template <
typename T>
451 _msgpack_load64(T, n, &dst);
457 :m_trail(0), m_user(f, user_data, limit), m_cs(MSGPACK_CS_HEADER)
459 m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
465 m_cs = MSGPACK_CS_HEADER;
473 return m_stack[0].obj();
486 int execute(
const char* data, std::size_t len, std::size_t& off);
489 template <
typename T>
490 static uint32_t next_cs(T p)
492 return static_cast<uint32_t
>(*p) & 0x1f;
495 template <
typename T,
typename Func>
498 uint32_t container_type,
500 const char* load_pos,
503 load<T>(tmp, load_pos);
504 f(m_user, tmp, m_stack.back().obj());
506 obj = m_stack.back().obj();
507 int ret = push_proc(obj, off);
508 if (ret != 0)
return ret;
511 m_stack.back().set_container_type(container_type);
512 m_stack.back().set_count(tmp);
513 if (m_stack.size() <= m_user.limit().depth()) {
519 m_cs = MSGPACK_CS_HEADER;
528 if(m_stack.size() == 1) {
533 case MSGPACK_CT_ARRAY_ITEM:
543 case MSGPACK_CT_MAP_KEY:
548 case MSGPACK_CT_MAP_VALUE:
567 int ret = push_item(obj);
569 m_stack[0].set_obj(obj);
572 off = m_current - m_start;
575 off = m_current - m_start;
578 m_cs = MSGPACK_CS_HEADER;
584 template <std::
size_t N>
585 static void check_ext_size(std::size_t ) {
590 char const* m_current;
595 std::vector<unpack_stack> m_stack;
599 inline void context::check_ext_size<4>(std::size_t size) {
603 inline int context::execute(
const char* data, std::size_t len, std::size_t& off)
608 m_current = data + off;
609 const char*
const pe = data + len;
610 const char* n =
nullptr;
614 if(m_current == pe) {
615 off = m_current - m_start;
618 bool fixed_trail_again =
false;
620 if (m_cs == MSGPACK_CS_HEADER) {
621 fixed_trail_again =
false;
622 int selector = *
reinterpret_cast<const unsigned char*
>(m_current);
623 if (0x00 <= selector && selector <= 0x7f) {
624 unpack_uint8(*reinterpret_cast<const uint8_t*>(m_current), obj);
625 int ret = push_proc(obj, off);
626 if (ret != 0)
return ret;
627 }
else if(0xe0 <= selector && selector <= 0xff) {
628 unpack_int8(*reinterpret_cast<const int8_t*>(m_current), obj);
629 int ret = push_proc(obj, off);
630 if (ret != 0)
return ret;
631 }
else if (0xc4 <= selector && selector <= 0xdf) {
632 const uint32_t trail[] = {
662 m_trail = trail[selector - 0xc4];
663 m_cs = next_cs(m_current);
664 fixed_trail_again =
true;
665 }
else if(0xa0 <= selector && selector <= 0xbf) {
666 m_trail =
static_cast<uint32_t
>(*m_current) & 0x1f;
668 unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
669 int ret = push_proc(obj, off);
670 if (ret != 0)
return ret;
673 m_cs = MSGPACK_ACS_STR_VALUE;
674 fixed_trail_again =
true;
677 }
else if(0x90 <= selector && selector <= 0x9f) {
678 int ret = push_aggregate<fix_tag>(
679 unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, m_current, off);
680 if (ret != 0)
return ret;
681 }
else if(0x80 <= selector && selector <= 0x8f) {
682 int ret = push_aggregate<fix_tag>(
683 unpack_map(), MSGPACK_CT_MAP_KEY, obj, m_current, off);
684 if (ret != 0)
return ret;
685 }
else if(selector == 0xc2) {
687 int ret = push_proc(obj, off);
688 if (ret != 0)
return ret;
689 }
else if(selector == 0xc3) {
691 int ret = push_proc(obj, off);
692 if (ret != 0)
return ret;
693 }
else if(selector == 0xc0) {
695 int ret = push_proc(obj, off);
696 if (ret != 0)
return ret;
698 off = m_current - m_start;
703 if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) {
704 if (fixed_trail_again) {
706 fixed_trail_again =
false;
708 if(static_cast<std::size_t>(pe - m_current) < m_trail) {
709 off = m_current - m_start;
713 m_current += m_trail - 1;
717 case MSGPACK_CS_FLOAT: {
718 union { uint32_t i;
float f; } mem;
719 load<uint32_t>(mem.i, n);
721 int ret = push_proc(obj, off);
722 if (ret != 0)
return ret;
724 case MSGPACK_CS_DOUBLE: {
725 union { uint64_t i;
double f; } mem;
726 load<uint64_t>(mem.i, n);
727 #if defined(TARGET_OS_IPHONE) 729 #elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi 731 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
734 int ret = push_proc(obj, off);
735 if (ret != 0)
return ret;
737 case MSGPACK_CS_UINT_8: {
739 load<uint8_t>(tmp, n);
741 int ret = push_proc(obj, off);
742 if (ret != 0)
return ret;
744 case MSGPACK_CS_UINT_16: {
746 load<uint16_t>(tmp, n);
748 int ret = push_proc(obj, off);
749 if (ret != 0)
return ret;
751 case MSGPACK_CS_UINT_32: {
753 load<uint32_t>(tmp, n);
755 int ret = push_proc(obj, off);
756 if (ret != 0)
return ret;
758 case MSGPACK_CS_UINT_64: {
760 load<uint64_t>(tmp, n);
762 int ret = push_proc(obj, off);
763 if (ret != 0)
return ret;
765 case MSGPACK_CS_INT_8: {
767 load<int8_t>(tmp, n);
769 int ret = push_proc(obj, off);
770 if (ret != 0)
return ret;
772 case MSGPACK_CS_INT_16: {
774 load<int16_t>(tmp, n);
776 int ret = push_proc(obj, off);
777 if (ret != 0)
return ret;
779 case MSGPACK_CS_INT_32: {
781 load<int32_t>(tmp, n);
783 int ret = push_proc(obj, off);
784 if (ret != 0)
return ret;
786 case MSGPACK_CS_INT_64: {
788 load<int64_t>(tmp, n);
790 int ret = push_proc(obj, off);
791 if (ret != 0)
return ret;
793 case MSGPACK_CS_FIXEXT_1: {
795 int ret = push_proc(obj, off);
796 if (ret != 0)
return ret;
798 case MSGPACK_CS_FIXEXT_2: {
800 int ret = push_proc(obj, off);
801 if (ret != 0)
return ret;
803 case MSGPACK_CS_FIXEXT_4: {
805 int ret = push_proc(obj, off);
806 if (ret != 0)
return ret;
808 case MSGPACK_CS_FIXEXT_8: {
810 int ret = push_proc(obj, off);
811 if (ret != 0)
return ret;
813 case MSGPACK_CS_FIXEXT_16: {
815 int ret = push_proc(obj, off);
816 if (ret != 0)
return ret;
818 case MSGPACK_CS_STR_8: {
820 load<uint8_t>(tmp, n);
823 unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
824 int ret = push_proc(obj, off);
825 if (ret != 0)
return ret;
828 m_cs = MSGPACK_ACS_STR_VALUE;
829 fixed_trail_again =
true;
832 case MSGPACK_CS_BIN_8: {
834 load<uint8_t>(tmp, n);
837 unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
838 int ret = push_proc(obj, off);
839 if (ret != 0)
return ret;
842 m_cs = MSGPACK_ACS_BIN_VALUE;
843 fixed_trail_again =
true;
846 case MSGPACK_CS_EXT_8: {
848 load<uint8_t>(tmp, n);
852 int ret = push_proc(obj, off);
853 if (ret != 0)
return ret;
856 m_cs = MSGPACK_ACS_EXT_VALUE;
857 fixed_trail_again =
true;
860 case MSGPACK_CS_STR_16: {
862 load<uint16_t>(tmp, n);
865 unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
866 int ret = push_proc(obj, off);
867 if (ret != 0)
return ret;
870 m_cs = MSGPACK_ACS_STR_VALUE;
871 fixed_trail_again =
true;
874 case MSGPACK_CS_BIN_16: {
876 load<uint16_t>(tmp, n);
879 unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
880 int ret = push_proc(obj, off);
881 if (ret != 0)
return ret;
884 m_cs = MSGPACK_ACS_BIN_VALUE;
885 fixed_trail_again =
true;
888 case MSGPACK_CS_EXT_16: {
890 load<uint16_t>(tmp, n);
894 int ret = push_proc(obj, off);
895 if (ret != 0)
return ret;
898 m_cs = MSGPACK_ACS_EXT_VALUE;
899 fixed_trail_again =
true;
902 case MSGPACK_CS_STR_32: {
904 load<uint32_t>(tmp, n);
907 unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
908 int ret = push_proc(obj, off);
909 if (ret != 0)
return ret;
912 m_cs = MSGPACK_ACS_STR_VALUE;
913 fixed_trail_again =
true;
916 case MSGPACK_CS_BIN_32: {
918 load<uint32_t>(tmp, n);
921 unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
922 int ret = push_proc(obj, off);
923 if (ret != 0)
return ret;
926 m_cs = MSGPACK_ACS_BIN_VALUE;
927 fixed_trail_again =
true;
930 case MSGPACK_CS_EXT_32: {
932 load<uint32_t>(tmp, n);
933 check_ext_size<sizeof(std::size_t)>(tmp);
938 int ret = push_proc(obj, off);
939 if (ret != 0)
return ret;
942 m_cs = MSGPACK_ACS_EXT_VALUE;
943 fixed_trail_again =
true;
946 case MSGPACK_ACS_STR_VALUE: {
947 unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj);
948 int ret = push_proc(obj, off);
949 if (ret != 0)
return ret;
951 case MSGPACK_ACS_BIN_VALUE: {
952 unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj);
953 int ret = push_proc(obj, off);
954 if (ret != 0)
return ret;
956 case MSGPACK_ACS_EXT_VALUE: {
958 int ret = push_proc(obj, off);
959 if (ret != 0)
return ret;
961 case MSGPACK_CS_ARRAY_16: {
962 int ret = push_aggregate<uint16_t>(
964 if (ret != 0)
return ret;
966 case MSGPACK_CS_ARRAY_32: {
968 int ret = push_aggregate<uint32_t>(
970 if (ret != 0)
return ret;
972 case MSGPACK_CS_MAP_16: {
973 int ret = push_aggregate<uint16_t>(
974 unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off);
975 if (ret != 0)
return ret;
977 case MSGPACK_CS_MAP_32: {
979 int ret = push_aggregate<uint32_t>(
980 unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off);
981 if (ret != 0)
return ret;
984 off = m_current - m_start;
988 }
while(m_current != pe);
990 off = m_current - m_start;
1012 void* user_data =
nullptr,
1016 #if !defined(MSGPACK_USE_CPP03) 1019 #endif // !defined(MSGPACK_USE_CPP03) 1049 std::size_t buffer_capacity()
const;
1061 void buffer_consumed(std::size_t size);
1077 bool next(unpacked* result);
1093 bool next(unpacked& result,
bool& referenced);
1107 bool next(unpacked& result);
1113 std::size_t message_size()
const;
1138 std::size_t parsed_size()
const;
1147 char* nonparsed_buffer();
1156 std::size_t nonparsed_size()
const;
1166 void skip_nonparsed_buffer(std::size_t size);
1173 void remove_nonparsed_buffer();
1176 void expand_buffer(std::size_t size);
1186 std::size_t m_parsed;
1188 std::size_t m_initial_buffer_size;
1191 #if defined(MSGPACK_USE_CPP03) 1195 #else // defined(MSGPACK_USE_CPP03) 1198 #endif // defined(MSGPACK_USE_CPP03) 1215 const char* data, std::size_t len, std::size_t& off,
bool& referenced,
1232 const char* data, std::size_t len, std::size_t& off,
1249 const char* data, std::size_t len,
bool& referenced,
1265 const char* data, std::size_t len,
1283 void unpack(unpacked& result,
1284 const char* data, std::size_t len, std::size_t& off,
bool& referenced,
1300 void unpack(unpacked& result,
1301 const char* data, std::size_t len, std::size_t& off,
1317 void unpack(unpacked& result,
1318 const char* data, std::size_t len,
bool& referenced,
1333 void unpack(unpacked& result,
1334 const char* data, std::size_t len,
1354 const char* data, std::size_t len, std::size_t& off,
bool& referenced,
1373 const char* data, std::size_t len, std::size_t& off,
1392 const char* data, std::size_t len,
bool& referenced,
1410 const char* data, std::size_t len,
1428 void unpack(unpacked* result,
1429 const char* data, std::size_t len, std::size_t* off =
nullptr,
bool* referenced =
nullptr,
1444 std::size_t initial_buffer_size,
1446 :m_z(new
msgpack::
zone), m_ctx(f, user_data, limit)
1452 char* buffer =
static_cast<char*
>(::malloc(initial_buffer_size));
1454 throw std::bad_alloc();
1459 m_free = initial_buffer_size - m_used;
1462 m_initial_buffer_size = initial_buffer_size;
1471 #if !defined(MSGPACK_USE_CPP03) 1475 :m_buffer(other.m_buffer),
1476 m_used(other.m_used),
1477 m_free(other.m_free),
1479 m_parsed(other.m_parsed),
1481 m_initial_buffer_size(other.m_initial_buffer_size),
1482 m_ctx(other.m_ctx) {
1483 other.m_buffer =
nullptr;
1492 #endif // !defined(MSGPACK_USE_CPP03) 1504 if(m_free >= size)
return;
1505 expand_buffer(size);
1508 inline void unpacker::expand_buffer(std::size_t size)
1517 if(m_free >= size)
return;
1521 std::size_t next_size = (m_used + m_free) * 2;
1522 while(next_size < size + m_used) {
1523 std::size_t tmp_next_size = next_size * 2;
1524 if (tmp_next_size <= next_size) {
1525 next_size = size + m_used;
1528 next_size = tmp_next_size;
1531 char* tmp =
static_cast<char*
>(::realloc(m_buffer, next_size));
1533 throw std::bad_alloc();
1537 m_free = next_size - m_used;
1540 std::size_t next_size = m_initial_buffer_size;
1541 std::size_t not_parsed = m_used - m_off;
1543 std::size_t tmp_next_size = next_size * 2;
1544 if (tmp_next_size <= next_size) {
1548 next_size = tmp_next_size;
1551 char* tmp =
static_cast<char*
>(::malloc(next_size));
1553 throw std::bad_alloc();
1558 std::memcpy(tmp+
COUNTER_SIZE, m_buffer + m_off, not_parsed);
1575 m_free = next_size - m_used;
1582 return m_buffer + m_used;
1599 int ret = execute_imp();
1605 result.
zone().reset();
1606 result.
set(
object());
1621 return next(result, referenced);
1626 return next(*result);
1632 int ret = execute_imp();
1635 }
else if(ret == 0) {
1642 inline int unpacker::execute_imp()
1644 std::size_t off = m_off;
1645 int ret = m_ctx.
execute(m_buffer, m_used, m_off);
1647 m_parsed += m_off - off;
1654 return m_ctx.
data();
1676 inline bool unpacker::flush_zone()
1701 return m_parsed - m_off + m_used;
1711 return m_buffer + m_off;
1716 return m_used - m_off;
1737 std::size_t noff = off;
1751 int e = ctx.
execute(data, len, noff);
1763 result = ctx.
data();
1777 const char* data, std::size_t len, std::size_t& off,
bool& referenced,
1783 std::size_t noff = off;
1785 data, len, noff, *z, obj, referenced, f, user_data, limit);
1804 const char* data, std::size_t len, std::size_t& off,
1808 return unpack(data, len, off, referenced, f, user_data, limit);
1812 const char* data, std::size_t len,
bool& referenced,
1815 std::size_t off = 0;
1816 return unpack(data, len, off, referenced, f, user_data, limit);
1820 const char* data, std::size_t len,
1824 std::size_t off = 0;
1825 return unpack(data, len, off, referenced, f, user_data, limit);
1829 const char* data, std::size_t len, std::size_t& off,
bool& referenced,
1835 std::size_t noff = off;
1837 data, len, noff, *z, obj, referenced, f, user_data, limit);
1859 const char* data, std::size_t len, std::size_t& off,
1863 unpack(result, data, len, off, referenced, f, user_data, limit);
1867 const char* data, std::size_t len,
bool& referenced,
1870 std::size_t off = 0;
1871 unpack(result, data, len, off, referenced, f, user_data, limit);
1875 const char* data, std::size_t len,
1879 std::size_t off = 0;
1880 unpack(result, data, len, off, referenced, f, user_data, limit);
1886 const char* data, std::size_t len, std::size_t& off,
bool& referenced,
1890 std::size_t noff = off;
1893 data, len, noff, z, obj, referenced, f, user_data, limit);
1913 const char* data, std::size_t len, std::size_t& off,
1917 return unpack(z, data, len, off, referenced, f, user_data, limit);
1922 const char* data, std::size_t len,
bool& referenced,
1925 std::size_t off = 0;
1926 return unpack(z, data, len, off, referenced, f, user_data, limit);
1931 const char* data, std::size_t len,
1935 std::size_t off = 0;
1936 return unpack(z, data, len, off, referenced, f, user_data, limit);
1942 const char* data, std::size_t len, std::size_t* off,
bool* referenced,
1946 if (referenced)
unpack(*result, data, len, *off, *referenced, f, user_data, limit);
1947 else unpack(*result, data, len, *off, f, user_data, limit);
1949 if (referenced)
unpack(*result, data, len, *referenced, f, user_data, limit);
1950 else unpack(*result, data, len, f, user_data, limit);
uint32_t type
Definition: unpack.hpp:426
ext_size_overflow(const std::string &msg)
Definition: unpack.hpp:149
unpack_return
Definition: unpack.hpp:1435
#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE
Definition: unpack.hpp:43
Definition: object_fwd.hpp:37
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
Definition: unpack.hpp:199
Definition: unpack.hpp:266
void operator()(unpack_user &u, uint32_t n, msgpack::object &o) const
Definition: unpack.hpp:267
char * nonparsed_buffer()
Get the address that is not parsed in the buffer.
Definition: unpack.hpp:1709
Definition: unpack.hpp:284
void unpack_int8(int8_t d, msgpack::object &o)
Definition: unpack.hpp:235
msgpack::object_kv * ptr
Definition: object_fwd.hpp:56
void incr_count(void *buffer)
Definition: unpack.hpp:395
Definition: unpack.hpp:166
Definition: unpack.hpp:130
context(unpack_reference_func f, void *user_data, unpack_limit const &limit)
Definition: unpack.hpp:456
uint32_t size
Definition: object_fwd.hpp:50
unpack_error(const std::string &msg)
Definition: unpack.hpp:77
std::size_t bin() const
Definition: unpack.hpp:184
void set_referenced(bool referenced)
Definition: unpack.hpp:209
const size_t COUNTER_SIZE
Definition: unpack.hpp:40
std::size_t ext() const
Definition: unpack.hpp:185
void * allocate_align(size_t size, size_t align=MSGPACK_ZONE_ALIGN)
Definition: cpp03_zone.hpp:248
~unpacker()
Definition: unpack.hpp:1495
void operator()(unpack_user &u, uint32_t n, msgpack::object &o) const
Definition: unpack.hpp:285
Definition: unpack.hpp:1437
Definition: object_fwd.hpp:30
const char * ptr
Definition: object_fwd.hpp:66
void unpack_ext(unpack_user &u, const char *p, std::size_t l, msgpack::object &o)
Definition: unpack.hpp:337
map_size_overflow(const std::string &msg)
Definition: unpack.hpp:122
void set_container_type(uint32_t container_type)
Definition: unpack.hpp:363
uint32_t container_type() const
Definition: unpack.hpp:362
void unpack_uint32(uint32_t d, msgpack::object &o)
Definition: unpack.hpp:229
std::size_t map() const
Definition: unpack.hpp:182
std::size_t nonparsed_size() const
Get the size of the buffer that is not parsed.
Definition: unpack.hpp:1714
void set(msgpack::object const &obj)
Definition: object.hpp:47
depth_size_overflow(const std::string &msg)
Definition: unpack.hpp:158
union_type via
Definition: object_fwd.hpp:123
std::size_t count() const
Definition: unpack.hpp:359
void unpack_str(unpack_user &u, const char *p, uint32_t l, msgpack::object &o)
Definition: unpack.hpp:305
bool execute()
Definition: unpack.hpp:1630
Definition: unpack.hpp:76
void load(T &dst, const char *n, typename msgpack::enable_if< sizeof(T)==8 >::type *=nullptr)
Definition: unpack.hpp:450
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.hpp:74
Definition: object_fwd.hpp:38
Definition: unpack.hpp:157
object_handle unpacked
Definition: unpack.hpp:997
void unpack_int16(int16_t d, msgpack::object &o)
Definition: unpack.hpp:239
void unpack_bin(unpack_user &u, const char *p, uint32_t l, msgpack::object &o)
Definition: unpack.hpp:321
const char * ptr
Definition: object_fwd.hpp:73
msgpack::object * ptr
Definition: object_fwd.hpp:51
parse_error(const std::string &msg)
Definition: unpack.hpp:86
void unpack_uint8(uint8_t d, msgpack::object &o)
Definition: unpack.hpp:223
msgpack::zone const & zone() const
Definition: unpack.hpp:205
int execute(const char *data, std::size_t len, std::size_t &off)
Definition: unpack.hpp:603
msgpack::object val
Definition: object_fwd.hpp:257
uint32_t size
Definition: object_fwd.hpp:65
T type
Definition: unpack.hpp:422
Definition: adaptor_base.hpp:15
Definition: unpack.hpp:85
Definition: unpack.hpp:148
unpack_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=nullptr, void *user_data=nullptr, unpack_limit const &limit=unpack_limit())
Definition: unpack.hpp:1732
const char * ptr
Definition: object_fwd.hpp:61
std::size_t parsed_size() const
Get parsed message size.
Definition: unpack.hpp:1704
Definition: cpp03_zone.hpp:34
void unpack_false(msgpack::object &o)
Definition: unpack.hpp:263
Definition: object_fwd.hpp:33
object_type
Definition: object_fwd.hpp:28
unpack_limit(std::size_t array=0xffffffff, std::size_t map=0xffffffff, std::size_t str=0xffffffff, std::size_t bin=0xffffffff, std::size_t ext=0xffffffff, std::size_t depth=0xffffffff)
Definition: unpack.hpp:168
bool boolean
Definition: object_fwd.hpp:108
Definition: unpack.hpp:1438
void set_obj(msgpack::object const &obj)
Definition: unpack.hpp:358
str_size_overflow(const std::string &msg)
Definition: unpack.hpp:131
Definition: unpack.hpp:1436
unpacker(unpack_reference_func f=&unpacker::default_reference_func, void *user_data=nullptr, std::size_t initial_buffer_size=MSGPACK_UNPACKER_INIT_BUFFER_SIZE, unpack_limit const &limit=unpack_limit())
Constructor.
Definition: unpack.hpp:1442
Definition: object_fwd.hpp:255
Definition: cpp_config.hpp:44
void remove_nonparsed_buffer()
Remove nonparsed buffer and reset the current position as a new start point.
Definition: unpack.hpp:1724
Definition: unpack.hpp:103
Definition: object_fwd.hpp:29
int64_t i64
Definition: object_fwd.hpp:110
Definition: object_fwd.hpp:32
array_size_overflow(const std::string &msg)
Definition: unpack.hpp:113
void reserve_buffer(std::size_t size=MSGPACK_UNPACKER_RESERVE_SIZE)
Reserve a buffer memory.
Definition: unpack.hpp:1502
Definition: unpack.hpp:454
void unpack_float(float d, msgpack::object &o)
Definition: unpack.hpp:251
Definition: unpack.hpp:139
void init_count(void *buffer)
Definition: unpack.hpp:373
void unpack_double(double d, msgpack::object &o)
Definition: unpack.hpp:254
unpack_reference_func reference_func() const
Definition: unpack.hpp:210
msgpack::object & obj()
Definition: unpack.hpp:357
void unpack_uint64(uint64_t d, msgpack::object &o)
Definition: unpack.hpp:232
uint32_t size
Definition: object_fwd.hpp:72
Definition: unpack.hpp:94
Definition: unpack.hpp:112
_msgpack_atomic_counter_t get_count(void *buffer)
Definition: unpack.hpp:405
void reset_zone()
Definition: unpack.hpp:1671
unpack_limit const & limit() const
Definition: unpack.hpp:212
msgpack::zone * release_zone()
Definition: unpack.hpp:1657
void unpack_int64(int64_t d, msgpack::object &o)
Definition: unpack.hpp:247
std::size_t str() const
Definition: unpack.hpp:183
void unpack_uint16(uint16_t d, msgpack::object &o)
Definition: unpack.hpp:226
void unpack_true(msgpack::object &o)
Definition: unpack.hpp:260
void set_map_key(msgpack::object const &map_key)
Definition: unpack.hpp:365
void buffer_consumed(std::size_t size)
Notify a buffer consumed information to msgpack::unpacker.
Definition: unpack.hpp:1590
double f64
Definition: object_fwd.hpp:114
msgpack::object const & data()
Definition: unpack.hpp:1652
Definition: object_fwd.hpp:41
insufficient_bytes(const std::string &msg)
Definition: unpack.hpp:95
msgpack::object_array array
Definition: object_fwd.hpp:115
char * buffer()
Get buffer pointer.
Definition: unpack.hpp:1580
void init()
Definition: unpack.hpp:463
Definition: cpp_config.hpp:64
msgpack::object_map map
Definition: object_fwd.hpp:116
msgpack::object_str str
Definition: object_fwd.hpp:117
std::size_t array() const
Definition: unpack.hpp:181
Object class that corresponding to MessagePack format object.
Definition: object_fwd.hpp:106
Definition: unpack.hpp:121
std::size_t message_size() const
Get message size.
Definition: unpack.hpp:1699
unpack_user & user()
Definition: unpack.hpp:476
msgpack::type::object_type type
Definition: object_fwd.hpp:122
msgpack::object const & data() const
Definition: unpack.hpp:471
msgpack::object const & map_key() const
Definition: unpack.hpp:364
Definition: unpack.hpp:354
Definition: object_fwd.hpp:39
void reset()
Definition: unpack.hpp:1692
msgpack::object key
Definition: object_fwd.hpp:256
Definition: unpack.hpp:1439
uint32_t size
Definition: object_fwd.hpp:55
Definition: object_fwd.hpp:40
msgpack::unique_ptr< msgpack::zone > & zone()
Get unique_ptr reference of zone.
Definition: object.hpp:61
void set_count(std::size_t count)
Definition: unpack.hpp:360
uint32_t size
Definition: object_fwd.hpp:60
size_overflow(const std::string &msg)
Definition: unpack.hpp:104
void unpack_nil(msgpack::object &o)
Definition: unpack.hpp:257
msgpack::zone & zone()
Definition: unpack.hpp:206
void unpack_map_item(msgpack::object &c, msgpack::object const &k, msgpack::object const &v)
Definition: unpack.hpp:293
void decr_count(void *buffer)
Definition: unpack.hpp:382
Unpacking class for a stream deserialization.
Definition: unpack.hpp:1000
Definition: unpack.hpp:416
std::size_t buffer_capacity() const
Get buffer capacity.
Definition: unpack.hpp:1585
void unpack_int32(int32_t d, msgpack::object &o)
Definition: unpack.hpp:243
unpack_limit & limit()
Definition: unpack.hpp:213
void unpack_array_item(msgpack::object &c, msgpack::object const &o)
Definition: unpack.hpp:275
T & move(T &t)
Definition: cpp_config.hpp:52
unpacked unpack(const char *data, std::size_t len, std::size_t &off, bool &referenced, unpack_reference_func f=nullptr, void *user_data=nullptr, unpack_limit const &limit=unpack_limit())
Unpack msgpack::object from a buffer.
Definition: unpack.hpp:1776
void * user_data() const
Definition: unpack.hpp:211
void set_zone(msgpack::zone &zone)
Definition: unpack.hpp:207
msgpack::object_ext ext
Definition: object_fwd.hpp:119
#define MSGPACK_UNPACKER_RESERVE_SIZE
Definition: unpack.hpp:47
Definition: unpack.hpp:421
std::size_t decr_count()
Definition: unpack.hpp:361
msgpack::object const & obj() const
Definition: unpack.hpp:356
void skip_nonparsed_buffer(std::size_t size)
Skip the specified size of non-parsed buffer.
Definition: unpack.hpp:1719
unpack_user(unpack_reference_func f=nullptr, void *user_data=nullptr, unpack_limit const &limit=unpack_limit())
Definition: unpack.hpp:201
unpack_user const & user() const
Definition: unpack.hpp:481
std::size_t depth() const
Definition: unpack.hpp:186
bin_size_overflow(const std::string &msg)
Definition: unpack.hpp:140
The class holds object and zone.
Definition: object.hpp:33
bool next(unpacked *result)
Unpack one msgpack::object. [obsolete].
Definition: unpack.hpp:1624
bool referenced() const
Definition: unpack.hpp:208
Definition: object_fwd.hpp:31
uint64_t u64
Definition: object_fwd.hpp:109
msgpack::object_bin bin
Definition: object_fwd.hpp:118