sq_detailed_metrics 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (69) hide show
  1. checksums.yaml +7 -0
  2. data/extconf.rb +26 -0
  3. data/include/half.hpp +4575 -0
  4. data/include/msgpack.h +24 -0
  5. data/include/msgpack/fbuffer.h +42 -0
  6. data/include/msgpack/gcc_atomic.h +25 -0
  7. data/include/msgpack/object.h +118 -0
  8. data/include/msgpack/pack.h +174 -0
  9. data/include/msgpack/pack_define.h +18 -0
  10. data/include/msgpack/pack_template.h +952 -0
  11. data/include/msgpack/sbuffer.h +115 -0
  12. data/include/msgpack/sysdep.h +221 -0
  13. data/include/msgpack/timestamp.h +58 -0
  14. data/include/msgpack/unpack.h +281 -0
  15. data/include/msgpack/unpack_define.h +89 -0
  16. data/include/msgpack/unpack_template.h +471 -0
  17. data/include/msgpack/util.h +15 -0
  18. data/include/msgpack/version.h +38 -0
  19. data/include/msgpack/version_master.h +3 -0
  20. data/include/msgpack/vrefbuffer.h +144 -0
  21. data/include/msgpack/zbuffer.h +205 -0
  22. data/include/msgpack/zone.h +163 -0
  23. data/include/rapidjson/allocators.h +271 -0
  24. data/include/rapidjson/document.h +2575 -0
  25. data/include/rapidjson/encodedstream.h +299 -0
  26. data/include/rapidjson/encodings.h +716 -0
  27. data/include/rapidjson/error/en.h +74 -0
  28. data/include/rapidjson/error/error.h +155 -0
  29. data/include/rapidjson/filereadstream.h +99 -0
  30. data/include/rapidjson/filewritestream.h +104 -0
  31. data/include/rapidjson/fwd.h +151 -0
  32. data/include/rapidjson/internal/biginteger.h +290 -0
  33. data/include/rapidjson/internal/diyfp.h +258 -0
  34. data/include/rapidjson/internal/dtoa.h +245 -0
  35. data/include/rapidjson/internal/ieee754.h +78 -0
  36. data/include/rapidjson/internal/itoa.h +304 -0
  37. data/include/rapidjson/internal/meta.h +181 -0
  38. data/include/rapidjson/internal/pow10.h +55 -0
  39. data/include/rapidjson/internal/regex.h +701 -0
  40. data/include/rapidjson/internal/stack.h +230 -0
  41. data/include/rapidjson/internal/strfunc.h +55 -0
  42. data/include/rapidjson/internal/strtod.h +269 -0
  43. data/include/rapidjson/internal/swap.h +46 -0
  44. data/include/rapidjson/istreamwrapper.h +115 -0
  45. data/include/rapidjson/memorybuffer.h +70 -0
  46. data/include/rapidjson/memorystream.h +71 -0
  47. data/include/rapidjson/msinttypes/inttypes.h +316 -0
  48. data/include/rapidjson/msinttypes/stdint.h +300 -0
  49. data/include/rapidjson/ostreamwrapper.h +81 -0
  50. data/include/rapidjson/pointer.h +1358 -0
  51. data/include/rapidjson/prettywriter.h +255 -0
  52. data/include/rapidjson/rapidjson.h +615 -0
  53. data/include/rapidjson/reader.h +1879 -0
  54. data/include/rapidjson/schema.h +2006 -0
  55. data/include/rapidjson/stream.h +179 -0
  56. data/include/rapidjson/stringbuffer.h +117 -0
  57. data/include/rapidjson/writer.h +610 -0
  58. data/include/xxhash.h +328 -0
  59. data/json_conv.cpp +284 -0
  60. data/json_conv.hpp +17 -0
  61. data/metrics.cpp +239 -0
  62. data/metrics.hpp +84 -0
  63. data/msgpack/objectc.c +482 -0
  64. data/msgpack/unpack.c +703 -0
  65. data/msgpack/version.c +22 -0
  66. data/msgpack/vrefbuffer.c +250 -0
  67. data/msgpack/zone.c +222 -0
  68. data/sq_detailed_metrics.cpp +248 -0
  69. metadata +199 -0
@@ -0,0 +1,115 @@
1
+ /*
2
+ * MessagePack for C simple buffer implementation
3
+ *
4
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
5
+ *
6
+ * Distributed under the Boost Software License, Version 1.0.
7
+ * (See accompanying file LICENSE_1_0.txt or copy at
8
+ * http://www.boost.org/LICENSE_1_0.txt)
9
+ */
10
+ #ifndef MSGPACK_SBUFFER_H
11
+ #define MSGPACK_SBUFFER_H
12
+
13
+ #include <stdlib.h>
14
+ #include <string.h>
15
+ #include <assert.h>
16
+
17
+ #ifdef __cplusplus
18
+ extern "C" {
19
+ #endif
20
+
21
+
22
+ /**
23
+ * @defgroup msgpack_sbuffer Simple buffer
24
+ * @ingroup msgpack_buffer
25
+ * @{
26
+ */
27
+
28
+ typedef struct msgpack_sbuffer {
29
+ size_t size;
30
+ char* data;
31
+ size_t alloc;
32
+ } msgpack_sbuffer;
33
+
34
+ static inline void msgpack_sbuffer_init(msgpack_sbuffer* sbuf)
35
+ {
36
+ memset(sbuf, 0, sizeof(msgpack_sbuffer));
37
+ }
38
+
39
+ static inline void msgpack_sbuffer_destroy(msgpack_sbuffer* sbuf)
40
+ {
41
+ free(sbuf->data);
42
+ }
43
+
44
+ static inline msgpack_sbuffer* msgpack_sbuffer_new(void)
45
+ {
46
+ return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer));
47
+ }
48
+
49
+ static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf)
50
+ {
51
+ if(sbuf == NULL) { return; }
52
+ msgpack_sbuffer_destroy(sbuf);
53
+ free(sbuf);
54
+ }
55
+
56
+ #ifndef MSGPACK_SBUFFER_INIT_SIZE
57
+ #define MSGPACK_SBUFFER_INIT_SIZE 8192
58
+ #endif
59
+
60
+ static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len)
61
+ {
62
+ msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data;
63
+
64
+ assert(buf || len == 0);
65
+ if(!buf) return 0;
66
+
67
+ if(sbuf->alloc - sbuf->size < len) {
68
+ void* tmp;
69
+ size_t nsize = (sbuf->alloc) ?
70
+ sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
71
+
72
+ while(nsize < sbuf->size + len) {
73
+ size_t tmp_nsize = nsize * 2;
74
+ if (tmp_nsize <= nsize) {
75
+ nsize = sbuf->size + len;
76
+ break;
77
+ }
78
+ nsize = tmp_nsize;
79
+ }
80
+
81
+ tmp = realloc(sbuf->data, nsize);
82
+ if(!tmp) { return -1; }
83
+
84
+ sbuf->data = (char*)tmp;
85
+ sbuf->alloc = nsize;
86
+ }
87
+
88
+ memcpy(sbuf->data + sbuf->size, buf, len);
89
+ sbuf->size += len;
90
+
91
+ return 0;
92
+ }
93
+
94
+ static inline char* msgpack_sbuffer_release(msgpack_sbuffer* sbuf)
95
+ {
96
+ char* tmp = sbuf->data;
97
+ sbuf->size = 0;
98
+ sbuf->data = NULL;
99
+ sbuf->alloc = 0;
100
+ return tmp;
101
+ }
102
+
103
+ static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf)
104
+ {
105
+ sbuf->size = 0;
106
+ }
107
+
108
+ /** @} */
109
+
110
+
111
+ #ifdef __cplusplus
112
+ }
113
+ #endif
114
+
115
+ #endif /* msgpack/sbuffer.h */
@@ -0,0 +1,221 @@
1
+ /*
2
+ * MessagePack system dependencies
3
+ *
4
+ * Copyright (C) 2008-2010 FURUHASHI Sadayuki
5
+ *
6
+ * Distributed under the Boost Software License, Version 1.0.
7
+ * (See accompanying file LICENSE_1_0.txt or copy at
8
+ * http://www.boost.org/LICENSE_1_0.txt)
9
+ */
10
+ #ifndef MSGPACK_SYSDEP_H
11
+ #define MSGPACK_SYSDEP_H
12
+
13
+ #include <stdlib.h>
14
+ #include <stddef.h>
15
+
16
+ #ifndef MSGPACK_ENDIAN_BIG_BYTE
17
+ #define MSGPACK_ENDIAN_BIG_BYTE 0
18
+ #endif
19
+ #ifndef MSGPACK_ENDIAN_LITTLE_BYTE
20
+ #define MSGPACK_ENDIAN_LITTLE_BYTE 1
21
+ #endif
22
+
23
+ #if defined(_MSC_VER) && _MSC_VER <= 1800
24
+ # define snprintf(buf, len, format,...) _snprintf_s(buf, len, _TRUNCATE, format, __VA_ARGS__)
25
+ #endif
26
+
27
+ #if defined(_MSC_VER) && _MSC_VER < 1600
28
+ typedef signed __int8 int8_t;
29
+ typedef unsigned __int8 uint8_t;
30
+ typedef signed __int16 int16_t;
31
+ typedef unsigned __int16 uint16_t;
32
+ typedef signed __int32 int32_t;
33
+ typedef unsigned __int32 uint32_t;
34
+ typedef signed __int64 int64_t;
35
+ typedef unsigned __int64 uint64_t;
36
+ #elif defined(_MSC_VER) // && _MSC_VER >= 1600
37
+ # include <stdint.h>
38
+ #else
39
+ # include <stdint.h>
40
+ # include <stdbool.h>
41
+ #endif
42
+
43
+ #if !defined(MSGPACK_DLLEXPORT)
44
+ #if defined(_MSC_VER)
45
+ # define MSGPACK_DLLEXPORT __declspec(dllexport)
46
+ #else /* _MSC_VER */
47
+ # define MSGPACK_DLLEXPORT
48
+ #endif /* _MSC_VER */
49
+ #endif
50
+
51
+ #ifdef _WIN32
52
+ # if defined(_KERNEL_MODE)
53
+ # define _msgpack_atomic_counter_header <ntddk.h>
54
+ # else
55
+ # define _msgpack_atomic_counter_header <windows.h>
56
+ # if !defined(WIN32_LEAN_AND_MEAN)
57
+ # define WIN32_LEAN_AND_MEAN
58
+ # endif /* WIN32_LEAN_AND_MEAN */
59
+ # endif
60
+ typedef long _msgpack_atomic_counter_t;
61
+ #if defined(_AMD64_) || defined(_M_X64) || defined(_M_ARM64)
62
+ # define _msgpack_sync_decr_and_fetch(ptr) _InterlockedDecrement(ptr)
63
+ # define _msgpack_sync_incr_and_fetch(ptr) _InterlockedIncrement(ptr)
64
+ #else
65
+ # define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr)
66
+ # define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr)
67
+ #endif
68
+ #elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41)
69
+
70
+ # if defined(__cplusplus)
71
+ # define _msgpack_atomic_counter_header "msgpack/gcc_atomic.hpp"
72
+ # else
73
+ # define _msgpack_atomic_counter_header "msgpack/gcc_atomic.h"
74
+ # endif
75
+
76
+ #else
77
+ typedef unsigned int _msgpack_atomic_counter_t;
78
+ # define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1)
79
+ # define _msgpack_sync_incr_and_fetch(ptr) __sync_add_and_fetch(ptr, 1)
80
+ #endif
81
+
82
+ #ifdef _WIN32
83
+
84
+ # ifdef __cplusplus
85
+ /* numeric_limits<T>::min,max */
86
+ # ifdef max
87
+ # undef max
88
+ # endif
89
+ # ifdef min
90
+ # undef min
91
+ # endif
92
+ # endif
93
+
94
+ #elif defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
95
+
96
+ #include <arpa/inet.h> /* __BYTE_ORDER */
97
+ # if defined(linux)
98
+ # include <byteswap.h>
99
+ # endif
100
+
101
+ #endif
102
+
103
+ #if !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE)
104
+ #include <msgpack/predef/other/endian.h>
105
+ #endif // !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE)
106
+
107
+ #if MSGPACK_ENDIAN_LITTLE_BYTE
108
+
109
+ # if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
110
+ # define _msgpack_be16(x) ntohs((uint16_t)x)
111
+ # else
112
+ # if defined(ntohs)
113
+ # define _msgpack_be16(x) ntohs(x)
114
+ # elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400)
115
+ # define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x))
116
+ # else
117
+ # define _msgpack_be16(x) ( \
118
+ ((((uint16_t)x) << 8) ) | \
119
+ ((((uint16_t)x) >> 8) ) )
120
+ # endif
121
+ # endif
122
+
123
+ # if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__)
124
+ # define _msgpack_be32(x) ntohl((uint32_t)x)
125
+ # else
126
+ # if defined(ntohl)
127
+ # define _msgpack_be32(x) ntohl(x)
128
+ # elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400)
129
+ # define _msgpack_be32(x) ((uint32_t)_byteswap_ulong((unsigned long)x))
130
+ # else
131
+ # define _msgpack_be32(x) \
132
+ ( ((((uint32_t)x) << 24) ) | \
133
+ ((((uint32_t)x) << 8) & 0x00ff0000U ) | \
134
+ ((((uint32_t)x) >> 8) & 0x0000ff00U ) | \
135
+ ((((uint32_t)x) >> 24) ) )
136
+ # endif
137
+ # endif
138
+
139
+ # if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400)
140
+ # define _msgpack_be64(x) (_byteswap_uint64(x))
141
+ # elif defined(bswap_64)
142
+ # define _msgpack_be64(x) bswap_64(x)
143
+ # elif defined(__DARWIN_OSSwapInt64)
144
+ # define _msgpack_be64(x) __DARWIN_OSSwapInt64(x)
145
+ # else
146
+ # define _msgpack_be64(x) \
147
+ ( ((((uint64_t)x) << 56) ) | \
148
+ ((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \
149
+ ((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \
150
+ ((((uint64_t)x) << 8) & 0x000000ff00000000ULL ) | \
151
+ ((((uint64_t)x) >> 8) & 0x00000000ff000000ULL ) | \
152
+ ((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \
153
+ ((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \
154
+ ((((uint64_t)x) >> 56) ) )
155
+ # endif
156
+
157
+ #elif MSGPACK_ENDIAN_BIG_BYTE
158
+
159
+ # define _msgpack_be16(x) (x)
160
+ # define _msgpack_be32(x) (x)
161
+ # define _msgpack_be64(x) (x)
162
+
163
+ #else
164
+ # error msgpack-c supports only big endian and little endian
165
+ #endif /* MSGPACK_ENDIAN_LITTLE_BYTE */
166
+
167
+ #define _msgpack_load16(cast, from, to) do { \
168
+ memcpy((cast*)(to), (from), sizeof(cast)); \
169
+ *(to) = (cast)_msgpack_be16(*(to)); \
170
+ } while (0);
171
+
172
+ #define _msgpack_load32(cast, from, to) do { \
173
+ memcpy((cast*)(to), (from), sizeof(cast)); \
174
+ *(to) = (cast)_msgpack_be32(*(to)); \
175
+ } while (0);
176
+ #define _msgpack_load64(cast, from, to) do { \
177
+ memcpy((cast*)(to), (from), sizeof(cast)); \
178
+ *(to) = (cast)_msgpack_be64(*(to)); \
179
+ } while (0);
180
+
181
+ #define _msgpack_store16(to, num) \
182
+ do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0)
183
+ #define _msgpack_store32(to, num) \
184
+ do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0)
185
+ #define _msgpack_store64(to, num) \
186
+ do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0)
187
+
188
+ /*
189
+ #define _msgpack_load16(cast, from) \
190
+ ({ cast val; memcpy(&val, (char*)from, 2); _msgpack_be16(val); })
191
+ #define _msgpack_load32(cast, from) \
192
+ ({ cast val; memcpy(&val, (char*)from, 4); _msgpack_be32(val); })
193
+ #define _msgpack_load64(cast, from) \
194
+ ({ cast val; memcpy(&val, (char*)from, 8); _msgpack_be64(val); })
195
+ */
196
+
197
+
198
+ #if !defined(__cplusplus) && defined(_MSC_VER)
199
+ # if !defined(_KERNEL_MODE)
200
+ # if !defined(FALSE)
201
+ # define FALSE (0)
202
+ # endif
203
+ # if !defined(TRUE)
204
+ # define TRUE (!FALSE)
205
+ # endif
206
+ # endif
207
+ # if _MSC_VER >= 1800
208
+ # include <stdbool.h>
209
+ # else
210
+ # define bool int
211
+ # define true TRUE
212
+ # define false FALSE
213
+ # endif
214
+ # define inline __inline
215
+ #endif
216
+
217
+ #ifdef __APPLE__
218
+ # include <TargetConditionals.h>
219
+ #endif
220
+
221
+ #endif /* msgpack/sysdep.h */
@@ -0,0 +1,58 @@
1
+ /*
2
+ * MessagePack for C TimeStamp
3
+ *
4
+ * Copyright (C) 2018 KONDO Takatoshi
5
+ *
6
+ * Distributed under the Boost Software License, Version 1.0.
7
+ * (See accompanying file LICENSE_1_0.txt or copy at
8
+ * http://www.boost.org/LICENSE_1_0.txt)
9
+ */
10
+ #ifndef MSGPACK_TIMESTAMP_H
11
+ #define MSGPACK_TIMESTAMP_H
12
+
13
+ #include <msgpack/object.h>
14
+
15
+ #ifdef __cplusplus
16
+ extern "C" {
17
+ #endif
18
+
19
+
20
+ typedef struct msgpack_timestamp {
21
+ int64_t tv_sec;
22
+ uint32_t tv_nsec;
23
+ } msgpack_timestamp;
24
+
25
+ static inline bool msgpack_object_to_timestamp(const msgpack_object* obj, msgpack_timestamp* ts) {
26
+ if (obj->type != MSGPACK_OBJECT_EXT) return false;
27
+ if (obj->via.ext.type != -1) return false;
28
+ switch (obj->via.ext.size) {
29
+ case 4:
30
+ ts->tv_nsec = 0;
31
+ {
32
+ uint32_t v;
33
+ _msgpack_load32(uint32_t, obj->via.ext.ptr, &v);
34
+ ts->tv_sec = v;
35
+ }
36
+ return true;
37
+ case 8: {
38
+ uint64_t value;
39
+ _msgpack_load64(uint64_t, obj->via.ext.ptr, &value);
40
+ ts->tv_nsec = (uint32_t)(value >> 34);
41
+ ts->tv_sec = value & 0x00000003ffffffffLL;
42
+ return true;
43
+ }
44
+ case 12:
45
+ _msgpack_load32(uint32_t, obj->via.ext.ptr, &ts->tv_nsec);
46
+ _msgpack_load64(int64_t, obj->via.ext.ptr + 4, &ts->tv_sec);
47
+ return true;
48
+ default:
49
+ return false;
50
+ }
51
+ }
52
+
53
+
54
+ #ifdef __cplusplus
55
+ }
56
+ #endif
57
+
58
+ #endif /* msgpack/timestamp.h */
@@ -0,0 +1,281 @@
1
+ /*
2
+ * MessagePack for C unpacking routine
3
+ *
4
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
5
+ *
6
+ * Distributed under the Boost Software License, Version 1.0.
7
+ * (See accompanying file LICENSE_1_0.txt or copy at
8
+ * http://www.boost.org/LICENSE_1_0.txt)
9
+ */
10
+ #ifndef MSGPACK_UNPACKER_H
11
+ #define MSGPACK_UNPACKER_H
12
+
13
+ #include "zone.h"
14
+ #include "object.h"
15
+ #include <string.h>
16
+
17
+ #ifdef __cplusplus
18
+ extern "C" {
19
+ #endif
20
+
21
+
22
+ /**
23
+ * @defgroup msgpack_unpack Deserializer
24
+ * @ingroup msgpack
25
+ * @{
26
+ */
27
+
28
+ typedef struct msgpack_unpacked {
29
+ msgpack_zone* zone;
30
+ msgpack_object data;
31
+ } msgpack_unpacked;
32
+
33
+ typedef enum {
34
+ MSGPACK_UNPACK_SUCCESS = 2,
35
+ MSGPACK_UNPACK_EXTRA_BYTES = 1,
36
+ MSGPACK_UNPACK_CONTINUE = 0,
37
+ MSGPACK_UNPACK_PARSE_ERROR = -1,
38
+ MSGPACK_UNPACK_NOMEM_ERROR = -2
39
+ } msgpack_unpack_return;
40
+
41
+
42
+ MSGPACK_DLLEXPORT
43
+ msgpack_unpack_return
44
+ msgpack_unpack_next(msgpack_unpacked* result,
45
+ const char* data, size_t len, size_t* off);
46
+
47
+ /** @} */
48
+
49
+
50
+ /**
51
+ * @defgroup msgpack_unpacker Streaming deserializer
52
+ * @ingroup msgpack
53
+ * @{
54
+ */
55
+
56
+ typedef struct msgpack_unpacker {
57
+ char* buffer;
58
+ size_t used;
59
+ size_t free;
60
+ size_t off;
61
+ size_t parsed;
62
+ msgpack_zone* z;
63
+ size_t initial_buffer_size;
64
+ void* ctx;
65
+ } msgpack_unpacker;
66
+
67
+
68
+ #ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE
69
+ #define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024)
70
+ #endif
71
+
72
+ /**
73
+ * Initializes a streaming deserializer.
74
+ * The initialized deserializer must be destroyed by msgpack_unpacker_destroy(msgpack_unpacker*).
75
+ */
76
+ MSGPACK_DLLEXPORT
77
+ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size);
78
+
79
+ /**
80
+ * Destroys a streaming deserializer initialized by msgpack_unpacker_init(msgpack_unpacker*, size_t).
81
+ */
82
+ MSGPACK_DLLEXPORT
83
+ void msgpack_unpacker_destroy(msgpack_unpacker* mpac);
84
+
85
+
86
+ /**
87
+ * Creates a streaming deserializer.
88
+ * The created deserializer must be destroyed by msgpack_unpacker_free(msgpack_unpacker*).
89
+ */
90
+ MSGPACK_DLLEXPORT
91
+ msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size);
92
+
93
+ /**
94
+ * Frees a streaming deserializer created by msgpack_unpacker_new(size_t).
95
+ */
96
+ MSGPACK_DLLEXPORT
97
+ void msgpack_unpacker_free(msgpack_unpacker* mpac);
98
+
99
+
100
+ #ifndef MSGPACK_UNPACKER_RESERVE_SIZE
101
+ #define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024)
102
+ #endif
103
+
104
+ /**
105
+ * Reserves free space of the internal buffer.
106
+ * Use this function to fill the internal buffer with
107
+ * msgpack_unpacker_buffer(msgpack_unpacker*),
108
+ * msgpack_unpacker_buffer_capacity(const msgpack_unpacker*) and
109
+ * msgpack_unpacker_buffer_consumed(msgpack_unpacker*).
110
+ */
111
+ static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size);
112
+
113
+ /**
114
+ * Gets pointer to the free space of the internal buffer.
115
+ * Use this function to fill the internal buffer with
116
+ * msgpack_unpacker_reserve_buffer(msgpack_unpacker*, size_t),
117
+ * msgpack_unpacker_buffer_capacity(const msgpack_unpacker*) and
118
+ * msgpack_unpacker_buffer_consumed(msgpack_unpacker*).
119
+ */
120
+ static inline char* msgpack_unpacker_buffer(msgpack_unpacker* mpac);
121
+
122
+ /**
123
+ * Gets size of the free space of the internal buffer.
124
+ * Use this function to fill the internal buffer with
125
+ * msgpack_unpacker_reserve_buffer(msgpack_unpacker*, size_t),
126
+ * msgpack_unpacker_buffer(const msgpack_unpacker*) and
127
+ * msgpack_unpacker_buffer_consumed(msgpack_unpacker*).
128
+ */
129
+ static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac);
130
+
131
+ /**
132
+ * Notifies the deserializer that the internal buffer filled.
133
+ * Use this function to fill the internal buffer with
134
+ * msgpack_unpacker_reserve_buffer(msgpack_unpacker*, size_t),
135
+ * msgpack_unpacker_buffer(msgpack_unpacker*) and
136
+ * msgpack_unpacker_buffer_capacity(const msgpack_unpacker*).
137
+ */
138
+ static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size);
139
+
140
+
141
+ /**
142
+ * Deserializes one object.
143
+ * Returns true if it successes. Otherwise false is returned.
144
+ * @param pac pointer to an initialized msgpack_unpacked object.
145
+ */
146
+ MSGPACK_DLLEXPORT
147
+ msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac);
148
+
149
+ /**
150
+ * Deserializes one object and set the number of parsed bytes involved.
151
+ * Returns true if it successes. Otherwise false is returned.
152
+ * @param mpac pointer to an initialized msgpack_unpacker object.
153
+ * @param result pointer to an initialized msgpack_unpacked object.
154
+ * @param p_bytes pointer to variable that will be set with the number of parsed bytes.
155
+ */
156
+ MSGPACK_DLLEXPORT
157
+ msgpack_unpack_return msgpack_unpacker_next_with_size(msgpack_unpacker* mpac,
158
+ msgpack_unpacked* result,
159
+ size_t *p_bytes);
160
+
161
+ /**
162
+ * Initializes a msgpack_unpacked object.
163
+ * The initialized object must be destroyed by msgpack_unpacked_destroy(msgpack_unpacker*).
164
+ * Use the object with msgpack_unpacker_next(msgpack_unpacker*, msgpack_unpacked*) or
165
+ * msgpack_unpack_next(msgpack_unpacked*, const char*, size_t, size_t*).
166
+ */
167
+ static inline void msgpack_unpacked_init(msgpack_unpacked* result);
168
+
169
+ /**
170
+ * Destroys a streaming deserializer initialized by msgpack_unpacked().
171
+ */
172
+ static inline void msgpack_unpacked_destroy(msgpack_unpacked* result);
173
+
174
+ /**
175
+ * Releases the memory zone from msgpack_unpacked object.
176
+ * The released zone must be freed by msgpack_zone_free(msgpack_zone*).
177
+ */
178
+ static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result);
179
+
180
+
181
+ MSGPACK_DLLEXPORT
182
+ int msgpack_unpacker_execute(msgpack_unpacker* mpac);
183
+
184
+ MSGPACK_DLLEXPORT
185
+ msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac);
186
+
187
+ MSGPACK_DLLEXPORT
188
+ msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac);
189
+
190
+ MSGPACK_DLLEXPORT
191
+ void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac);
192
+
193
+ MSGPACK_DLLEXPORT
194
+ void msgpack_unpacker_reset(msgpack_unpacker* mpac);
195
+
196
+ static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac);
197
+
198
+
199
+ /** @} */
200
+
201
+
202
+ // obsolete
203
+ MSGPACK_DLLEXPORT
204
+ msgpack_unpack_return
205
+ msgpack_unpack(const char* data, size_t len, size_t* off,
206
+ msgpack_zone* result_zone, msgpack_object* result);
207
+
208
+
209
+
210
+
211
+ static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac);
212
+
213
+ MSGPACK_DLLEXPORT
214
+ bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac);
215
+
216
+ MSGPACK_DLLEXPORT
217
+ bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size);
218
+
219
+ static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size)
220
+ {
221
+ if(mpac->free >= size) { return true; }
222
+ return msgpack_unpacker_expand_buffer(mpac, size);
223
+ }
224
+
225
+ static inline char* msgpack_unpacker_buffer(msgpack_unpacker* mpac)
226
+ {
227
+ return mpac->buffer + mpac->used;
228
+ }
229
+
230
+ static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac)
231
+ {
232
+ return mpac->free;
233
+ }
234
+
235
+ static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size)
236
+ {
237
+ mpac->used += size;
238
+ mpac->free -= size;
239
+ }
240
+
241
+ static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac)
242
+ {
243
+ return mpac->parsed - mpac->off + mpac->used;
244
+ }
245
+
246
+ static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac)
247
+ {
248
+ return mpac->parsed;
249
+ }
250
+
251
+
252
+ static inline void msgpack_unpacked_init(msgpack_unpacked* result)
253
+ {
254
+ memset(result, 0, sizeof(msgpack_unpacked));
255
+ }
256
+
257
+ static inline void msgpack_unpacked_destroy(msgpack_unpacked* result)
258
+ {
259
+ if(result->zone != NULL) {
260
+ msgpack_zone_free(result->zone);
261
+ result->zone = NULL;
262
+ memset(&result->data, 0, sizeof(msgpack_object));
263
+ }
264
+ }
265
+
266
+ static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result)
267
+ {
268
+ if(result->zone != NULL) {
269
+ msgpack_zone* z = result->zone;
270
+ result->zone = NULL;
271
+ return z;
272
+ }
273
+ return NULL;
274
+ }
275
+
276
+
277
+ #ifdef __cplusplus
278
+ }
279
+ #endif
280
+
281
+ #endif /* msgpack/unpack.h */