MessagePack for C++
unpack.hpp
Go to the documentation of this file.
1 //
2 // MessagePack for C++ deserializing routine
3 //
4 // Copyright (C) 2016 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_V2_UNPACK_HPP
11 #define MSGPACK_V2_UNPACK_HPP
12 
13 #include "msgpack/unpack_decl.hpp"
15 #include "msgpack/v2/parse.hpp"
16 
17 namespace msgpack {
18 
22 
23 
26  void set_zone(msgpack::zone& z) { m_z = &z; }
27  void operator()(char* buffer) {
29  }
31 };
32 
33 class unpacker : public parser<unpacker, zone_push_finalizer>,
36 public:
37  unpacker(unpack_reference_func f = &unpacker::default_reference_func,
38  void* user_data = MSGPACK_NULLPTR,
39  std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE,
40  unpack_limit const& limit = unpack_limit())
41  :parser_t(m_finalizer, initial_buffer_size),
42  detail::create_object_visitor(f, user_data, limit),
43  m_z(new msgpack::zone),
44  m_finalizer(*m_z) {
45  set_zone(*m_z);
46  set_referenced(false);
47  }
48 
51 
64  bool next(msgpack::object_handle& result, bool& referenced);
65 
67 
78  bool next(msgpack::object_handle& result);
79  msgpack::zone* release_zone();
80  void reset_zone();
81  bool flush_zone();
82 private:
83  static bool default_reference_func(msgpack::type::object_type /*type*/, std::size_t /*len*/, void*) {
84  return true;
85  }
87  zone_push_finalizer m_finalizer;
88 };
89 
90 inline bool unpacker::next(msgpack::object_handle& result, bool& referenced) {
91  bool ret = parser_t::next();
92  if (ret) {
94  result.zone().reset( release_zone() );
95  result.set(data());
96  reset();
97  }
98  else {
99  result.zone().reset();
100  result.set(msgpack::object());
101  }
102  return ret;
103 }
104 
105 inline bool unpacker::next(msgpack::object_handle& result) {
106  bool referenced;
107  return next(result, referenced);
108 }
109 
111 {
112  if(!flush_zone()) {
113  return MSGPACK_NULLPTR;
114  }
115 
116  msgpack::zone* r = new msgpack::zone;
117  msgpack::zone* old = m_z.release();
118  m_z.reset(r);
119  set_zone(*m_z);
120  m_finalizer.set_zone(*m_z);
121 
122  return old;
123 }
124 
125 inline void unpacker::reset_zone()
126 {
127  m_z->clear();
128 }
129 
130 inline bool unpacker::flush_zone()
131 {
132  if(referenced()) {
133  try {
134  m_z->push_finalizer(&detail::decr_count, get_raw_buffer());
135  } catch (...) {
136  return false;
137  }
138  set_referenced(false);
139 
140  detail::incr_count(get_raw_buffer());
141  }
142 
143  return true;
144 }
145 
147  const char* data, std::size_t len, std::size_t& off, bool& referenced,
148  unpack_reference_func f, void* user_data,
149  unpack_limit const& limit
150 )
151 {
152  msgpack::object obj;
154  referenced = false;
155  std::size_t noff = off;
157  data, len, noff, *z, obj, referenced, f, user_data, limit);
158 
159  switch(ret) {
160  case PARSE_SUCCESS:
161  off = noff;
162  return msgpack::object_handle(obj, msgpack::move(z));
163  case PARSE_EXTRA_BYTES:
164  off = noff;
165  return msgpack::object_handle(obj, msgpack::move(z));
166  default:
167  break;
168  }
169  return msgpack::object_handle();
170 }
171 
173  const char* data, std::size_t len, std::size_t& off,
174  unpack_reference_func f, void* user_data,
175  unpack_limit const& limit)
176 {
177  bool referenced;
178  return msgpack::v2::unpack(data, len, off, referenced, f, user_data, limit);
179 }
180 
182  const char* data, std::size_t len, bool& referenced,
183  unpack_reference_func f, void* user_data,
184  unpack_limit const& limit)
185 {
186  std::size_t off = 0;
187  return msgpack::v2::unpack(data, len, off, referenced, f, user_data, limit);
188 }
189 
191  const char* data, std::size_t len,
192  unpack_reference_func f, void* user_data,
193  unpack_limit const& limit)
194 {
195  bool referenced;
196  std::size_t off = 0;
197  return msgpack::v2::unpack(data, len, off, referenced, f, user_data, limit);
198 }
199 
200 inline void unpack(
201  msgpack::object_handle& result,
202  const char* data, std::size_t len, std::size_t& off, bool& referenced,
203  unpack_reference_func f, void* user_data,
204  unpack_limit const& limit)
205 {
206  msgpack::object obj;
208  referenced = false;
209  std::size_t noff = off;
211  data, len, noff, *z, obj, referenced, f, user_data, limit);
212 
213  switch(ret) {
214  case PARSE_SUCCESS:
215  off = noff;
216  result.set(obj);
217  result.zone() = msgpack::move(z);
218  return;
219  case PARSE_EXTRA_BYTES:
220  off = noff;
221  result.set(obj);
222  result.zone() = msgpack::move(z);
223  return;
224  default:
225  return;
226  }
227 }
228 
229 inline void unpack(
230  msgpack::object_handle& result,
231  const char* data, std::size_t len, std::size_t& off,
232  msgpack::v2::unpack_reference_func f, void* user_data,
233  unpack_limit const& limit)
234 {
235  bool referenced;
236  msgpack::v2::unpack(result, data, len, off, referenced, f, user_data, limit);
237 }
238 
239 inline void unpack(
240  msgpack::object_handle& result,
241  const char* data, std::size_t len, bool& referenced,
242  unpack_reference_func f, void* user_data,
243  unpack_limit const& limit)
244 {
245  std::size_t off = 0;
246  msgpack::v2::unpack(result, data, len, off, referenced, f, user_data, limit);
247 }
248 
249 inline void unpack(
250  msgpack::object_handle& result,
251  const char* data, std::size_t len,
252  unpack_reference_func f, void* user_data,
253  unpack_limit const& limit)
254 {
255  bool referenced;
256  std::size_t off = 0;
257  msgpack::v2::unpack(result, data, len, off, referenced, f, user_data, limit);
258 }
259 
260 
261 inline msgpack::object unpack(
262  msgpack::zone& z,
263  const char* data, std::size_t len, std::size_t& off, bool& referenced,
264  unpack_reference_func f, void* user_data,
265  unpack_limit const& limit)
266 {
267  msgpack::object obj;
268  std::size_t noff = off;
269  referenced = false;
271  data, len, noff, z, obj, referenced, f, user_data, limit);
272 
273  switch(ret) {
274  case PARSE_SUCCESS:
275  off = noff;
276  return obj;
277  case PARSE_EXTRA_BYTES:
278  off = noff;
279  return obj;
280  default:
281  break;
282  }
283  return obj;
284 }
285 
286 inline msgpack::object unpack(
287  msgpack::zone& z,
288  const char* data, std::size_t len, std::size_t& off,
289  unpack_reference_func f, void* user_data,
290  unpack_limit const& limit)
291 {
292  bool referenced;
293  return msgpack::v2::unpack(z, data, len, off, referenced, f, user_data, limit);
294 }
295 
296 inline msgpack::object unpack(
297  msgpack::zone& z,
298  const char* data, std::size_t len, bool& referenced,
299  unpack_reference_func f, void* user_data,
300  unpack_limit const& limit)
301 {
302  std::size_t off = 0;
303  return msgpack::v2::unpack(z, data, len, off, referenced, f, user_data, limit);
304 }
305 
306 inline msgpack::object unpack(
307  msgpack::zone& z,
308  const char* data, std::size_t len,
309  unpack_reference_func f, void* user_data,
310  unpack_limit const& limit)
311 {
312  bool referenced;
313  std::size_t off = 0;
314  return msgpack::v2::unpack(z, data, len, off, referenced, f, user_data, limit);
315 }
316 
317 namespace detail {
318 
319 inline parse_return
320 unpack_imp(const char* data, std::size_t len, std::size_t& off,
321  msgpack::zone& result_zone, msgpack::object& result, bool& referenced,
323  unpack_limit const& limit = unpack_limit())
324 {
325  create_object_visitor v(f, user_data, limit);
326  v.set_zone(result_zone);
327  referenced = false;
328  v.set_referenced(referenced);
329  parse_return ret = parse_imp(data, len, off, v);
330  referenced = v.referenced();
331  result = v.data();
332  return ret;
333 }
334 
335 } // namespace detail
336 
337 
339 } // MSGPACK_API_VERSION_NAMESPACE(v2)
341 
342 } // namespace msgpack
343 
344 
345 #endif // MSGPACK_V2_UNPACK_HPP
bool next()
Unpack one msgpack::object.
Definition: parse.hpp:938
void incr_count(void *buffer)
Definition: unpack.hpp:248
Definition: unpack_decl.hpp:87
void set_zone(msgpack::zone &z)
Definition: unpack.hpp:26
msgpack::zone * m_z
Definition: unpack.hpp:30
#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE
Definition: unpack_decl.hpp:43
parse_return
Definition: parse_return.hpp:23
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:1339
void unpack(msgpack::object_handle &result, const char *data, std::size_t len, std::size_t &off, msgpack::v2::unpack_reference_func f, void *user_data, unpack_limit const &limit)
Definition: unpack.hpp:229
void set(msgpack::object const &obj)
Definition: object.hpp:63
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
detail::create_object_visitor & visitor()
Definition: unpack.hpp:49
void operator()(char *buffer)
Definition: unpack.hpp:27
bool referenced() const
Definition: create_object_visitor.hpp:63
Definition: adaptor_base.hpp:15
Definition: cpp03_zone.hpp:22
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())
Definition: unpack.hpp:37
Definition: unpack.hpp:24
object_type
Definition: object_fwd_decl.hpp:28
void push_finalizer(void(*func)(void *), void *data)
Definition: cpp03_zone.hpp:301
void reset_zone()
Definition: unpack.hpp:1278
msgpack::zone * release_zone()
Definition: unpack.hpp:1264
void clear()
Definition: cpp03_zone.hpp:312
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:1383
Object class that corresponding to MessagePack format object.
Definition: object_fwd.hpp:75
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
Definition: parse_return.hpp:24
parse_return parse_imp(const char *data, size_t len, size_t &off, Visitor &v)
Definition: parse.hpp:1025
Definition: parse_return.hpp:25
msgpack::unique_ptr< msgpack::zone > & zone()
Get unique_ptr reference of zone.
Definition: object.hpp:77
zone_push_finalizer(msgpack::zone &z)
Definition: unpack.hpp:25
void decr_count(void *buffer)
Definition: unpack.hpp:235
Unpacking class for a stream deserialization.
Definition: unpack.hpp:847
#define MSGPACK_NULLPTR
Definition: cpp_config_decl.hpp:35
T & move(T &t)
Definition: create_object_visitor.hpp:25
Parsing class for a stream deserialization.
Definition: parse.hpp:618
The class holds object and zone.
Definition: object.hpp:43