MessagePack for C++
cpp03_define_map.hpp
Go to the documentation of this file.
1 //
2 // MessagePack for C++ static resolution routine
3 //
4 // Copyright (C) 2015-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_V1_CPP03_DEFINE_MAP_HPP
11 #define MSGPACK_V1_CPP03_DEFINE_MAP_HPP
12 
13 #include "msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp"
14 #include "msgpack/adaptor/msgpack_tuple.hpp"
15 #include "msgpack/adaptor/adaptor_base.hpp"
16 #include "msgpack/object_fwd.hpp"
17 
18 #include <map>
19 
20 namespace msgpack {
22 MSGPACK_API_VERSION_NAMESPACE(v1) {
24 namespace type {
25 
26 
27 template <>
28 struct define_map<> {
29  template <typename Packer>
30  void msgpack_pack(Packer& pk) const
31  {
32  pk.pack_map(0);
33  }
34  void msgpack_unpack(msgpack::object const& o) const
35  {
36  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
37  }
38  void msgpack_object(msgpack::object* o, msgpack::zone&) const
39  {
40  o->type = msgpack::type::MAP;
41  o->via.map.ptr = MSGPACK_NULLPTR;
42  o->via.map.size = 0;
43  }
44 };
45 
47 
48 template <typename A0, typename A1>
49 struct define_map<A0, A1> {
50  define_map(A0& _a0, A1& _a1) :
51  a0(_a0), a1(_a1) {}
52  template <typename Packer>
53  void msgpack_pack(Packer& pk) const
54  {
55  pk.pack_map(1);
56 
57  pk.pack(a0);
58  pk.pack(a1);
59  }
60  void msgpack_unpack(msgpack::object const& o) const
61  {
62  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
63  std::map<std::string, msgpack::object const*> kvmap;
64  for (uint32_t i = 0; i < o.via.map.size; ++i) {
65  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
66  kvmap.insert(
67  std::map<std::string, msgpack::object const*>::value_type(
68  std::string(
69  o.via.map.ptr[i].key.via.str.ptr,
70  o.via.map.ptr[i].key.via.str.size),
71  &o.via.map.ptr[i].val
72  )
73  );
74  }
75 
76  {
77  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
78  if (it != kvmap.end()) {
79  it->second->convert(a1);
80  }
81  }
82 
83  }
84  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
85  {
86  o->type = msgpack::type::MAP;
87  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*1, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
88  o->via.map.size = 1;
89 
90  o->via.map.ptr[0].key = msgpack::object(a0, z);
91  o->via.map.ptr[0].val = msgpack::object(a1, z);
92 
93  }
94 
95  A0& a0;
96  A1& a1;
97 };
98 
99 template <typename A0, typename A1, typename A2, typename A3>
100 struct define_map<A0, A1, A2, A3> {
101  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3) :
102  a0(_a0), a1(_a1), a2(_a2), a3(_a3) {}
103  template <typename Packer>
104  void msgpack_pack(Packer& pk) const
105  {
106  pk.pack_map(2);
107 
108  pk.pack(a0);
109  pk.pack(a1);
110  pk.pack(a2);
111  pk.pack(a3);
112  }
113  void msgpack_unpack(msgpack::object const& o) const
114  {
115  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
116  std::map<std::string, msgpack::object const*> kvmap;
117  for (uint32_t i = 0; i < o.via.map.size; ++i) {
118  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
119  kvmap.insert(
120  std::map<std::string, msgpack::object const*>::value_type(
121  std::string(
122  o.via.map.ptr[i].key.via.str.ptr,
123  o.via.map.ptr[i].key.via.str.size),
124  &o.via.map.ptr[i].val
125  )
126  );
127  }
128 
129  {
130  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
131  if (it != kvmap.end()) {
132  it->second->convert(a1);
133  }
134  }
135 
136  {
137  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
138  if (it != kvmap.end()) {
139  it->second->convert(a3);
140  }
141  }
142 
143  }
144  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
145  {
146  o->type = msgpack::type::MAP;
147  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*2, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
148  o->via.map.size = 2;
149 
150  o->via.map.ptr[0].key = msgpack::object(a0, z);
151  o->via.map.ptr[0].val = msgpack::object(a1, z);
152 
153  o->via.map.ptr[1].key = msgpack::object(a2, z);
154  o->via.map.ptr[1].val = msgpack::object(a3, z);
155 
156  }
157 
158  A0& a0;
159  A1& a1;
160  A2& a2;
161  A3& a3;
162 };
163 
164 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
165 struct define_map<A0, A1, A2, A3, A4, A5> {
166  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) :
167  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {}
168  template <typename Packer>
169  void msgpack_pack(Packer& pk) const
170  {
171  pk.pack_map(3);
172 
173  pk.pack(a0);
174  pk.pack(a1);
175  pk.pack(a2);
176  pk.pack(a3);
177  pk.pack(a4);
178  pk.pack(a5);
179  }
180  void msgpack_unpack(msgpack::object const& o) const
181  {
182  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
183  std::map<std::string, msgpack::object const*> kvmap;
184  for (uint32_t i = 0; i < o.via.map.size; ++i) {
185  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
186  kvmap.insert(
187  std::map<std::string, msgpack::object const*>::value_type(
188  std::string(
189  o.via.map.ptr[i].key.via.str.ptr,
190  o.via.map.ptr[i].key.via.str.size),
191  &o.via.map.ptr[i].val
192  )
193  );
194  }
195 
196  {
197  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
198  if (it != kvmap.end()) {
199  it->second->convert(a1);
200  }
201  }
202 
203  {
204  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
205  if (it != kvmap.end()) {
206  it->second->convert(a3);
207  }
208  }
209 
210  {
211  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
212  if (it != kvmap.end()) {
213  it->second->convert(a5);
214  }
215  }
216 
217  }
218  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
219  {
220  o->type = msgpack::type::MAP;
221  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*3, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
222  o->via.map.size = 3;
223 
224  o->via.map.ptr[0].key = msgpack::object(a0, z);
225  o->via.map.ptr[0].val = msgpack::object(a1, z);
226 
227  o->via.map.ptr[1].key = msgpack::object(a2, z);
228  o->via.map.ptr[1].val = msgpack::object(a3, z);
229 
230  o->via.map.ptr[2].key = msgpack::object(a4, z);
231  o->via.map.ptr[2].val = msgpack::object(a5, z);
232 
233  }
234 
235  A0& a0;
236  A1& a1;
237  A2& a2;
238  A3& a3;
239  A4& a4;
240  A5& a5;
241 };
242 
243 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
244 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7> {
245  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) :
246  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {}
247  template <typename Packer>
248  void msgpack_pack(Packer& pk) const
249  {
250  pk.pack_map(4);
251 
252  pk.pack(a0);
253  pk.pack(a1);
254  pk.pack(a2);
255  pk.pack(a3);
256  pk.pack(a4);
257  pk.pack(a5);
258  pk.pack(a6);
259  pk.pack(a7);
260  }
261  void msgpack_unpack(msgpack::object const& o) const
262  {
263  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
264  std::map<std::string, msgpack::object const*> kvmap;
265  for (uint32_t i = 0; i < o.via.map.size; ++i) {
266  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
267  kvmap.insert(
268  std::map<std::string, msgpack::object const*>::value_type(
269  std::string(
270  o.via.map.ptr[i].key.via.str.ptr,
271  o.via.map.ptr[i].key.via.str.size),
272  &o.via.map.ptr[i].val
273  )
274  );
275  }
276 
277  {
278  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
279  if (it != kvmap.end()) {
280  it->second->convert(a1);
281  }
282  }
283 
284  {
285  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
286  if (it != kvmap.end()) {
287  it->second->convert(a3);
288  }
289  }
290 
291  {
292  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
293  if (it != kvmap.end()) {
294  it->second->convert(a5);
295  }
296  }
297 
298  {
299  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
300  if (it != kvmap.end()) {
301  it->second->convert(a7);
302  }
303  }
304 
305  }
306  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
307  {
308  o->type = msgpack::type::MAP;
309  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*4, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
310  o->via.map.size = 4;
311 
312  o->via.map.ptr[0].key = msgpack::object(a0, z);
313  o->via.map.ptr[0].val = msgpack::object(a1, z);
314 
315  o->via.map.ptr[1].key = msgpack::object(a2, z);
316  o->via.map.ptr[1].val = msgpack::object(a3, z);
317 
318  o->via.map.ptr[2].key = msgpack::object(a4, z);
319  o->via.map.ptr[2].val = msgpack::object(a5, z);
320 
321  o->via.map.ptr[3].key = msgpack::object(a6, z);
322  o->via.map.ptr[3].val = msgpack::object(a7, z);
323 
324  }
325 
326  A0& a0;
327  A1& a1;
328  A2& a2;
329  A3& a3;
330  A4& a4;
331  A5& a5;
332  A6& a6;
333  A7& a7;
334 };
335 
336 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
337 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> {
338  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) :
339  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {}
340  template <typename Packer>
341  void msgpack_pack(Packer& pk) const
342  {
343  pk.pack_map(5);
344 
345  pk.pack(a0);
346  pk.pack(a1);
347  pk.pack(a2);
348  pk.pack(a3);
349  pk.pack(a4);
350  pk.pack(a5);
351  pk.pack(a6);
352  pk.pack(a7);
353  pk.pack(a8);
354  pk.pack(a9);
355  }
356  void msgpack_unpack(msgpack::object const& o) const
357  {
358  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
359  std::map<std::string, msgpack::object const*> kvmap;
360  for (uint32_t i = 0; i < o.via.map.size; ++i) {
361  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
362  kvmap.insert(
363  std::map<std::string, msgpack::object const*>::value_type(
364  std::string(
365  o.via.map.ptr[i].key.via.str.ptr,
366  o.via.map.ptr[i].key.via.str.size),
367  &o.via.map.ptr[i].val
368  )
369  );
370  }
371 
372  {
373  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
374  if (it != kvmap.end()) {
375  it->second->convert(a1);
376  }
377  }
378 
379  {
380  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
381  if (it != kvmap.end()) {
382  it->second->convert(a3);
383  }
384  }
385 
386  {
387  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
388  if (it != kvmap.end()) {
389  it->second->convert(a5);
390  }
391  }
392 
393  {
394  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
395  if (it != kvmap.end()) {
396  it->second->convert(a7);
397  }
398  }
399 
400  {
401  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
402  if (it != kvmap.end()) {
403  it->second->convert(a9);
404  }
405  }
406 
407  }
408  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
409  {
410  o->type = msgpack::type::MAP;
411  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*5, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
412  o->via.map.size = 5;
413 
414  o->via.map.ptr[0].key = msgpack::object(a0, z);
415  o->via.map.ptr[0].val = msgpack::object(a1, z);
416 
417  o->via.map.ptr[1].key = msgpack::object(a2, z);
418  o->via.map.ptr[1].val = msgpack::object(a3, z);
419 
420  o->via.map.ptr[2].key = msgpack::object(a4, z);
421  o->via.map.ptr[2].val = msgpack::object(a5, z);
422 
423  o->via.map.ptr[3].key = msgpack::object(a6, z);
424  o->via.map.ptr[3].val = msgpack::object(a7, z);
425 
426  o->via.map.ptr[4].key = msgpack::object(a8, z);
427  o->via.map.ptr[4].val = msgpack::object(a9, z);
428 
429  }
430 
431  A0& a0;
432  A1& a1;
433  A2& a2;
434  A3& a3;
435  A4& a4;
436  A5& a5;
437  A6& a6;
438  A7& a7;
439  A8& a8;
440  A9& a9;
441 };
442 
443 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
444 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> {
445  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) :
446  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {}
447  template <typename Packer>
448  void msgpack_pack(Packer& pk) const
449  {
450  pk.pack_map(6);
451 
452  pk.pack(a0);
453  pk.pack(a1);
454  pk.pack(a2);
455  pk.pack(a3);
456  pk.pack(a4);
457  pk.pack(a5);
458  pk.pack(a6);
459  pk.pack(a7);
460  pk.pack(a8);
461  pk.pack(a9);
462  pk.pack(a10);
463  pk.pack(a11);
464  }
465  void msgpack_unpack(msgpack::object const& o) const
466  {
467  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
468  std::map<std::string, msgpack::object const*> kvmap;
469  for (uint32_t i = 0; i < o.via.map.size; ++i) {
470  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
471  kvmap.insert(
472  std::map<std::string, msgpack::object const*>::value_type(
473  std::string(
474  o.via.map.ptr[i].key.via.str.ptr,
475  o.via.map.ptr[i].key.via.str.size),
476  &o.via.map.ptr[i].val
477  )
478  );
479  }
480 
481  {
482  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
483  if (it != kvmap.end()) {
484  it->second->convert(a1);
485  }
486  }
487 
488  {
489  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
490  if (it != kvmap.end()) {
491  it->second->convert(a3);
492  }
493  }
494 
495  {
496  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
497  if (it != kvmap.end()) {
498  it->second->convert(a5);
499  }
500  }
501 
502  {
503  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
504  if (it != kvmap.end()) {
505  it->second->convert(a7);
506  }
507  }
508 
509  {
510  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
511  if (it != kvmap.end()) {
512  it->second->convert(a9);
513  }
514  }
515 
516  {
517  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
518  if (it != kvmap.end()) {
519  it->second->convert(a11);
520  }
521  }
522 
523  }
524  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
525  {
526  o->type = msgpack::type::MAP;
527  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*6, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
528  o->via.map.size = 6;
529 
530  o->via.map.ptr[0].key = msgpack::object(a0, z);
531  o->via.map.ptr[0].val = msgpack::object(a1, z);
532 
533  o->via.map.ptr[1].key = msgpack::object(a2, z);
534  o->via.map.ptr[1].val = msgpack::object(a3, z);
535 
536  o->via.map.ptr[2].key = msgpack::object(a4, z);
537  o->via.map.ptr[2].val = msgpack::object(a5, z);
538 
539  o->via.map.ptr[3].key = msgpack::object(a6, z);
540  o->via.map.ptr[3].val = msgpack::object(a7, z);
541 
542  o->via.map.ptr[4].key = msgpack::object(a8, z);
543  o->via.map.ptr[4].val = msgpack::object(a9, z);
544 
545  o->via.map.ptr[5].key = msgpack::object(a10, z);
546  o->via.map.ptr[5].val = msgpack::object(a11, z);
547 
548  }
549 
550  A0& a0;
551  A1& a1;
552  A2& a2;
553  A3& a3;
554  A4& a4;
555  A5& a5;
556  A6& a6;
557  A7& a7;
558  A8& a8;
559  A9& a9;
560  A10& a10;
561  A11& a11;
562 };
563 
564 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
565 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> {
566  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) :
567  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {}
568  template <typename Packer>
569  void msgpack_pack(Packer& pk) const
570  {
571  pk.pack_map(7);
572 
573  pk.pack(a0);
574  pk.pack(a1);
575  pk.pack(a2);
576  pk.pack(a3);
577  pk.pack(a4);
578  pk.pack(a5);
579  pk.pack(a6);
580  pk.pack(a7);
581  pk.pack(a8);
582  pk.pack(a9);
583  pk.pack(a10);
584  pk.pack(a11);
585  pk.pack(a12);
586  pk.pack(a13);
587  }
588  void msgpack_unpack(msgpack::object const& o) const
589  {
590  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
591  std::map<std::string, msgpack::object const*> kvmap;
592  for (uint32_t i = 0; i < o.via.map.size; ++i) {
593  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
594  kvmap.insert(
595  std::map<std::string, msgpack::object const*>::value_type(
596  std::string(
597  o.via.map.ptr[i].key.via.str.ptr,
598  o.via.map.ptr[i].key.via.str.size),
599  &o.via.map.ptr[i].val
600  )
601  );
602  }
603 
604  {
605  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
606  if (it != kvmap.end()) {
607  it->second->convert(a1);
608  }
609  }
610 
611  {
612  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
613  if (it != kvmap.end()) {
614  it->second->convert(a3);
615  }
616  }
617 
618  {
619  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
620  if (it != kvmap.end()) {
621  it->second->convert(a5);
622  }
623  }
624 
625  {
626  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
627  if (it != kvmap.end()) {
628  it->second->convert(a7);
629  }
630  }
631 
632  {
633  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
634  if (it != kvmap.end()) {
635  it->second->convert(a9);
636  }
637  }
638 
639  {
640  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
641  if (it != kvmap.end()) {
642  it->second->convert(a11);
643  }
644  }
645 
646  {
647  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
648  if (it != kvmap.end()) {
649  it->second->convert(a13);
650  }
651  }
652 
653  }
654  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
655  {
656  o->type = msgpack::type::MAP;
657  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*7, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
658  o->via.map.size = 7;
659 
660  o->via.map.ptr[0].key = msgpack::object(a0, z);
661  o->via.map.ptr[0].val = msgpack::object(a1, z);
662 
663  o->via.map.ptr[1].key = msgpack::object(a2, z);
664  o->via.map.ptr[1].val = msgpack::object(a3, z);
665 
666  o->via.map.ptr[2].key = msgpack::object(a4, z);
667  o->via.map.ptr[2].val = msgpack::object(a5, z);
668 
669  o->via.map.ptr[3].key = msgpack::object(a6, z);
670  o->via.map.ptr[3].val = msgpack::object(a7, z);
671 
672  o->via.map.ptr[4].key = msgpack::object(a8, z);
673  o->via.map.ptr[4].val = msgpack::object(a9, z);
674 
675  o->via.map.ptr[5].key = msgpack::object(a10, z);
676  o->via.map.ptr[5].val = msgpack::object(a11, z);
677 
678  o->via.map.ptr[6].key = msgpack::object(a12, z);
679  o->via.map.ptr[6].val = msgpack::object(a13, z);
680 
681  }
682 
683  A0& a0;
684  A1& a1;
685  A2& a2;
686  A3& a3;
687  A4& a4;
688  A5& a5;
689  A6& a6;
690  A7& a7;
691  A8& a8;
692  A9& a9;
693  A10& a10;
694  A11& a11;
695  A12& a12;
696  A13& a13;
697 };
698 
699 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
700 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> {
701  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) :
702  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {}
703  template <typename Packer>
704  void msgpack_pack(Packer& pk) const
705  {
706  pk.pack_map(8);
707 
708  pk.pack(a0);
709  pk.pack(a1);
710  pk.pack(a2);
711  pk.pack(a3);
712  pk.pack(a4);
713  pk.pack(a5);
714  pk.pack(a6);
715  pk.pack(a7);
716  pk.pack(a8);
717  pk.pack(a9);
718  pk.pack(a10);
719  pk.pack(a11);
720  pk.pack(a12);
721  pk.pack(a13);
722  pk.pack(a14);
723  pk.pack(a15);
724  }
725  void msgpack_unpack(msgpack::object const& o) const
726  {
727  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
728  std::map<std::string, msgpack::object const*> kvmap;
729  for (uint32_t i = 0; i < o.via.map.size; ++i) {
730  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
731  kvmap.insert(
732  std::map<std::string, msgpack::object const*>::value_type(
733  std::string(
734  o.via.map.ptr[i].key.via.str.ptr,
735  o.via.map.ptr[i].key.via.str.size),
736  &o.via.map.ptr[i].val
737  )
738  );
739  }
740 
741  {
742  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
743  if (it != kvmap.end()) {
744  it->second->convert(a1);
745  }
746  }
747 
748  {
749  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
750  if (it != kvmap.end()) {
751  it->second->convert(a3);
752  }
753  }
754 
755  {
756  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
757  if (it != kvmap.end()) {
758  it->second->convert(a5);
759  }
760  }
761 
762  {
763  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
764  if (it != kvmap.end()) {
765  it->second->convert(a7);
766  }
767  }
768 
769  {
770  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
771  if (it != kvmap.end()) {
772  it->second->convert(a9);
773  }
774  }
775 
776  {
777  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
778  if (it != kvmap.end()) {
779  it->second->convert(a11);
780  }
781  }
782 
783  {
784  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
785  if (it != kvmap.end()) {
786  it->second->convert(a13);
787  }
788  }
789 
790  {
791  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
792  if (it != kvmap.end()) {
793  it->second->convert(a15);
794  }
795  }
796 
797  }
798  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
799  {
800  o->type = msgpack::type::MAP;
801  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*8, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
802  o->via.map.size = 8;
803 
804  o->via.map.ptr[0].key = msgpack::object(a0, z);
805  o->via.map.ptr[0].val = msgpack::object(a1, z);
806 
807  o->via.map.ptr[1].key = msgpack::object(a2, z);
808  o->via.map.ptr[1].val = msgpack::object(a3, z);
809 
810  o->via.map.ptr[2].key = msgpack::object(a4, z);
811  o->via.map.ptr[2].val = msgpack::object(a5, z);
812 
813  o->via.map.ptr[3].key = msgpack::object(a6, z);
814  o->via.map.ptr[3].val = msgpack::object(a7, z);
815 
816  o->via.map.ptr[4].key = msgpack::object(a8, z);
817  o->via.map.ptr[4].val = msgpack::object(a9, z);
818 
819  o->via.map.ptr[5].key = msgpack::object(a10, z);
820  o->via.map.ptr[5].val = msgpack::object(a11, z);
821 
822  o->via.map.ptr[6].key = msgpack::object(a12, z);
823  o->via.map.ptr[6].val = msgpack::object(a13, z);
824 
825  o->via.map.ptr[7].key = msgpack::object(a14, z);
826  o->via.map.ptr[7].val = msgpack::object(a15, z);
827 
828  }
829 
830  A0& a0;
831  A1& a1;
832  A2& a2;
833  A3& a3;
834  A4& a4;
835  A5& a5;
836  A6& a6;
837  A7& a7;
838  A8& a8;
839  A9& a9;
840  A10& a10;
841  A11& a11;
842  A12& a12;
843  A13& a13;
844  A14& a14;
845  A15& a15;
846 };
847 
848 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
849 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> {
850  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) :
851  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {}
852  template <typename Packer>
853  void msgpack_pack(Packer& pk) const
854  {
855  pk.pack_map(9);
856 
857  pk.pack(a0);
858  pk.pack(a1);
859  pk.pack(a2);
860  pk.pack(a3);
861  pk.pack(a4);
862  pk.pack(a5);
863  pk.pack(a6);
864  pk.pack(a7);
865  pk.pack(a8);
866  pk.pack(a9);
867  pk.pack(a10);
868  pk.pack(a11);
869  pk.pack(a12);
870  pk.pack(a13);
871  pk.pack(a14);
872  pk.pack(a15);
873  pk.pack(a16);
874  pk.pack(a17);
875  }
876  void msgpack_unpack(msgpack::object const& o) const
877  {
878  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
879  std::map<std::string, msgpack::object const*> kvmap;
880  for (uint32_t i = 0; i < o.via.map.size; ++i) {
881  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
882  kvmap.insert(
883  std::map<std::string, msgpack::object const*>::value_type(
884  std::string(
885  o.via.map.ptr[i].key.via.str.ptr,
886  o.via.map.ptr[i].key.via.str.size),
887  &o.via.map.ptr[i].val
888  )
889  );
890  }
891 
892  {
893  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
894  if (it != kvmap.end()) {
895  it->second->convert(a1);
896  }
897  }
898 
899  {
900  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
901  if (it != kvmap.end()) {
902  it->second->convert(a3);
903  }
904  }
905 
906  {
907  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
908  if (it != kvmap.end()) {
909  it->second->convert(a5);
910  }
911  }
912 
913  {
914  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
915  if (it != kvmap.end()) {
916  it->second->convert(a7);
917  }
918  }
919 
920  {
921  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
922  if (it != kvmap.end()) {
923  it->second->convert(a9);
924  }
925  }
926 
927  {
928  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
929  if (it != kvmap.end()) {
930  it->second->convert(a11);
931  }
932  }
933 
934  {
935  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
936  if (it != kvmap.end()) {
937  it->second->convert(a13);
938  }
939  }
940 
941  {
942  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
943  if (it != kvmap.end()) {
944  it->second->convert(a15);
945  }
946  }
947 
948  {
949  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
950  if (it != kvmap.end()) {
951  it->second->convert(a17);
952  }
953  }
954 
955  }
956  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
957  {
958  o->type = msgpack::type::MAP;
959  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*9, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
960  o->via.map.size = 9;
961 
962  o->via.map.ptr[0].key = msgpack::object(a0, z);
963  o->via.map.ptr[0].val = msgpack::object(a1, z);
964 
965  o->via.map.ptr[1].key = msgpack::object(a2, z);
966  o->via.map.ptr[1].val = msgpack::object(a3, z);
967 
968  o->via.map.ptr[2].key = msgpack::object(a4, z);
969  o->via.map.ptr[2].val = msgpack::object(a5, z);
970 
971  o->via.map.ptr[3].key = msgpack::object(a6, z);
972  o->via.map.ptr[3].val = msgpack::object(a7, z);
973 
974  o->via.map.ptr[4].key = msgpack::object(a8, z);
975  o->via.map.ptr[4].val = msgpack::object(a9, z);
976 
977  o->via.map.ptr[5].key = msgpack::object(a10, z);
978  o->via.map.ptr[5].val = msgpack::object(a11, z);
979 
980  o->via.map.ptr[6].key = msgpack::object(a12, z);
981  o->via.map.ptr[6].val = msgpack::object(a13, z);
982 
983  o->via.map.ptr[7].key = msgpack::object(a14, z);
984  o->via.map.ptr[7].val = msgpack::object(a15, z);
985 
986  o->via.map.ptr[8].key = msgpack::object(a16, z);
987  o->via.map.ptr[8].val = msgpack::object(a17, z);
988 
989  }
990 
991  A0& a0;
992  A1& a1;
993  A2& a2;
994  A3& a3;
995  A4& a4;
996  A5& a5;
997  A6& a6;
998  A7& a7;
999  A8& a8;
1000  A9& a9;
1001  A10& a10;
1002  A11& a11;
1003  A12& a12;
1004  A13& a13;
1005  A14& a14;
1006  A15& a15;
1007  A16& a16;
1008  A17& a17;
1009 };
1010 
1011 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19>
1012 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> {
1013  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) :
1014  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {}
1015  template <typename Packer>
1016  void msgpack_pack(Packer& pk) const
1017  {
1018  pk.pack_map(10);
1019 
1020  pk.pack(a0);
1021  pk.pack(a1);
1022  pk.pack(a2);
1023  pk.pack(a3);
1024  pk.pack(a4);
1025  pk.pack(a5);
1026  pk.pack(a6);
1027  pk.pack(a7);
1028  pk.pack(a8);
1029  pk.pack(a9);
1030  pk.pack(a10);
1031  pk.pack(a11);
1032  pk.pack(a12);
1033  pk.pack(a13);
1034  pk.pack(a14);
1035  pk.pack(a15);
1036  pk.pack(a16);
1037  pk.pack(a17);
1038  pk.pack(a18);
1039  pk.pack(a19);
1040  }
1041  void msgpack_unpack(msgpack::object const& o) const
1042  {
1043  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
1044  std::map<std::string, msgpack::object const*> kvmap;
1045  for (uint32_t i = 0; i < o.via.map.size; ++i) {
1046  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
1047  kvmap.insert(
1048  std::map<std::string, msgpack::object const*>::value_type(
1049  std::string(
1050  o.via.map.ptr[i].key.via.str.ptr,
1051  o.via.map.ptr[i].key.via.str.size),
1052  &o.via.map.ptr[i].val
1053  )
1054  );
1055  }
1056 
1057  {
1058  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
1059  if (it != kvmap.end()) {
1060  it->second->convert(a1);
1061  }
1062  }
1063 
1064  {
1065  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
1066  if (it != kvmap.end()) {
1067  it->second->convert(a3);
1068  }
1069  }
1070 
1071  {
1072  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
1073  if (it != kvmap.end()) {
1074  it->second->convert(a5);
1075  }
1076  }
1077 
1078  {
1079  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
1080  if (it != kvmap.end()) {
1081  it->second->convert(a7);
1082  }
1083  }
1084 
1085  {
1086  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
1087  if (it != kvmap.end()) {
1088  it->second->convert(a9);
1089  }
1090  }
1091 
1092  {
1093  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
1094  if (it != kvmap.end()) {
1095  it->second->convert(a11);
1096  }
1097  }
1098 
1099  {
1100  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
1101  if (it != kvmap.end()) {
1102  it->second->convert(a13);
1103  }
1104  }
1105 
1106  {
1107  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
1108  if (it != kvmap.end()) {
1109  it->second->convert(a15);
1110  }
1111  }
1112 
1113  {
1114  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
1115  if (it != kvmap.end()) {
1116  it->second->convert(a17);
1117  }
1118  }
1119 
1120  {
1121  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a18);
1122  if (it != kvmap.end()) {
1123  it->second->convert(a19);
1124  }
1125  }
1126 
1127  }
1128  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
1129  {
1130  o->type = msgpack::type::MAP;
1131  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*10, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
1132  o->via.map.size = 10;
1133 
1134  o->via.map.ptr[0].key = msgpack::object(a0, z);
1135  o->via.map.ptr[0].val = msgpack::object(a1, z);
1136 
1137  o->via.map.ptr[1].key = msgpack::object(a2, z);
1138  o->via.map.ptr[1].val = msgpack::object(a3, z);
1139 
1140  o->via.map.ptr[2].key = msgpack::object(a4, z);
1141  o->via.map.ptr[2].val = msgpack::object(a5, z);
1142 
1143  o->via.map.ptr[3].key = msgpack::object(a6, z);
1144  o->via.map.ptr[3].val = msgpack::object(a7, z);
1145 
1146  o->via.map.ptr[4].key = msgpack::object(a8, z);
1147  o->via.map.ptr[4].val = msgpack::object(a9, z);
1148 
1149  o->via.map.ptr[5].key = msgpack::object(a10, z);
1150  o->via.map.ptr[5].val = msgpack::object(a11, z);
1151 
1152  o->via.map.ptr[6].key = msgpack::object(a12, z);
1153  o->via.map.ptr[6].val = msgpack::object(a13, z);
1154 
1155  o->via.map.ptr[7].key = msgpack::object(a14, z);
1156  o->via.map.ptr[7].val = msgpack::object(a15, z);
1157 
1158  o->via.map.ptr[8].key = msgpack::object(a16, z);
1159  o->via.map.ptr[8].val = msgpack::object(a17, z);
1160 
1161  o->via.map.ptr[9].key = msgpack::object(a18, z);
1162  o->via.map.ptr[9].val = msgpack::object(a19, z);
1163 
1164  }
1165 
1166  A0& a0;
1167  A1& a1;
1168  A2& a2;
1169  A3& a3;
1170  A4& a4;
1171  A5& a5;
1172  A6& a6;
1173  A7& a7;
1174  A8& a8;
1175  A9& a9;
1176  A10& a10;
1177  A11& a11;
1178  A12& a12;
1179  A13& a13;
1180  A14& a14;
1181  A15& a15;
1182  A16& a16;
1183  A17& a17;
1184  A18& a18;
1185  A19& a19;
1186 };
1187 
1188 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
1189 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> {
1190  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) :
1191  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {}
1192  template <typename Packer>
1193  void msgpack_pack(Packer& pk) const
1194  {
1195  pk.pack_map(11);
1196 
1197  pk.pack(a0);
1198  pk.pack(a1);
1199  pk.pack(a2);
1200  pk.pack(a3);
1201  pk.pack(a4);
1202  pk.pack(a5);
1203  pk.pack(a6);
1204  pk.pack(a7);
1205  pk.pack(a8);
1206  pk.pack(a9);
1207  pk.pack(a10);
1208  pk.pack(a11);
1209  pk.pack(a12);
1210  pk.pack(a13);
1211  pk.pack(a14);
1212  pk.pack(a15);
1213  pk.pack(a16);
1214  pk.pack(a17);
1215  pk.pack(a18);
1216  pk.pack(a19);
1217  pk.pack(a20);
1218  pk.pack(a21);
1219  }
1220  void msgpack_unpack(msgpack::object const& o) const
1221  {
1222  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
1223  std::map<std::string, msgpack::object const*> kvmap;
1224  for (uint32_t i = 0; i < o.via.map.size; ++i) {
1225  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
1226  kvmap.insert(
1227  std::map<std::string, msgpack::object const*>::value_type(
1228  std::string(
1229  o.via.map.ptr[i].key.via.str.ptr,
1230  o.via.map.ptr[i].key.via.str.size),
1231  &o.via.map.ptr[i].val
1232  )
1233  );
1234  }
1235 
1236  {
1237  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
1238  if (it != kvmap.end()) {
1239  it->second->convert(a1);
1240  }
1241  }
1242 
1243  {
1244  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
1245  if (it != kvmap.end()) {
1246  it->second->convert(a3);
1247  }
1248  }
1249 
1250  {
1251  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
1252  if (it != kvmap.end()) {
1253  it->second->convert(a5);
1254  }
1255  }
1256 
1257  {
1258  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
1259  if (it != kvmap.end()) {
1260  it->second->convert(a7);
1261  }
1262  }
1263 
1264  {
1265  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
1266  if (it != kvmap.end()) {
1267  it->second->convert(a9);
1268  }
1269  }
1270 
1271  {
1272  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
1273  if (it != kvmap.end()) {
1274  it->second->convert(a11);
1275  }
1276  }
1277 
1278  {
1279  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
1280  if (it != kvmap.end()) {
1281  it->second->convert(a13);
1282  }
1283  }
1284 
1285  {
1286  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
1287  if (it != kvmap.end()) {
1288  it->second->convert(a15);
1289  }
1290  }
1291 
1292  {
1293  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
1294  if (it != kvmap.end()) {
1295  it->second->convert(a17);
1296  }
1297  }
1298 
1299  {
1300  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a18);
1301  if (it != kvmap.end()) {
1302  it->second->convert(a19);
1303  }
1304  }
1305 
1306  {
1307  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a20);
1308  if (it != kvmap.end()) {
1309  it->second->convert(a21);
1310  }
1311  }
1312 
1313  }
1314  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
1315  {
1316  o->type = msgpack::type::MAP;
1317  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*11, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
1318  o->via.map.size = 11;
1319 
1320  o->via.map.ptr[0].key = msgpack::object(a0, z);
1321  o->via.map.ptr[0].val = msgpack::object(a1, z);
1322 
1323  o->via.map.ptr[1].key = msgpack::object(a2, z);
1324  o->via.map.ptr[1].val = msgpack::object(a3, z);
1325 
1326  o->via.map.ptr[2].key = msgpack::object(a4, z);
1327  o->via.map.ptr[2].val = msgpack::object(a5, z);
1328 
1329  o->via.map.ptr[3].key = msgpack::object(a6, z);
1330  o->via.map.ptr[3].val = msgpack::object(a7, z);
1331 
1332  o->via.map.ptr[4].key = msgpack::object(a8, z);
1333  o->via.map.ptr[4].val = msgpack::object(a9, z);
1334 
1335  o->via.map.ptr[5].key = msgpack::object(a10, z);
1336  o->via.map.ptr[5].val = msgpack::object(a11, z);
1337 
1338  o->via.map.ptr[6].key = msgpack::object(a12, z);
1339  o->via.map.ptr[6].val = msgpack::object(a13, z);
1340 
1341  o->via.map.ptr[7].key = msgpack::object(a14, z);
1342  o->via.map.ptr[7].val = msgpack::object(a15, z);
1343 
1344  o->via.map.ptr[8].key = msgpack::object(a16, z);
1345  o->via.map.ptr[8].val = msgpack::object(a17, z);
1346 
1347  o->via.map.ptr[9].key = msgpack::object(a18, z);
1348  o->via.map.ptr[9].val = msgpack::object(a19, z);
1349 
1350  o->via.map.ptr[10].key = msgpack::object(a20, z);
1351  o->via.map.ptr[10].val = msgpack::object(a21, z);
1352 
1353  }
1354 
1355  A0& a0;
1356  A1& a1;
1357  A2& a2;
1358  A3& a3;
1359  A4& a4;
1360  A5& a5;
1361  A6& a6;
1362  A7& a7;
1363  A8& a8;
1364  A9& a9;
1365  A10& a10;
1366  A11& a11;
1367  A12& a12;
1368  A13& a13;
1369  A14& a14;
1370  A15& a15;
1371  A16& a16;
1372  A17& a17;
1373  A18& a18;
1374  A19& a19;
1375  A20& a20;
1376  A21& a21;
1377 };
1378 
1379 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
1380 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> {
1381  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) :
1382  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {}
1383  template <typename Packer>
1384  void msgpack_pack(Packer& pk) const
1385  {
1386  pk.pack_map(12);
1387 
1388  pk.pack(a0);
1389  pk.pack(a1);
1390  pk.pack(a2);
1391  pk.pack(a3);
1392  pk.pack(a4);
1393  pk.pack(a5);
1394  pk.pack(a6);
1395  pk.pack(a7);
1396  pk.pack(a8);
1397  pk.pack(a9);
1398  pk.pack(a10);
1399  pk.pack(a11);
1400  pk.pack(a12);
1401  pk.pack(a13);
1402  pk.pack(a14);
1403  pk.pack(a15);
1404  pk.pack(a16);
1405  pk.pack(a17);
1406  pk.pack(a18);
1407  pk.pack(a19);
1408  pk.pack(a20);
1409  pk.pack(a21);
1410  pk.pack(a22);
1411  pk.pack(a23);
1412  }
1413  void msgpack_unpack(msgpack::object const& o) const
1414  {
1415  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
1416  std::map<std::string, msgpack::object const*> kvmap;
1417  for (uint32_t i = 0; i < o.via.map.size; ++i) {
1418  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
1419  kvmap.insert(
1420  std::map<std::string, msgpack::object const*>::value_type(
1421  std::string(
1422  o.via.map.ptr[i].key.via.str.ptr,
1423  o.via.map.ptr[i].key.via.str.size),
1424  &o.via.map.ptr[i].val
1425  )
1426  );
1427  }
1428 
1429  {
1430  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
1431  if (it != kvmap.end()) {
1432  it->second->convert(a1);
1433  }
1434  }
1435 
1436  {
1437  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
1438  if (it != kvmap.end()) {
1439  it->second->convert(a3);
1440  }
1441  }
1442 
1443  {
1444  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
1445  if (it != kvmap.end()) {
1446  it->second->convert(a5);
1447  }
1448  }
1449 
1450  {
1451  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
1452  if (it != kvmap.end()) {
1453  it->second->convert(a7);
1454  }
1455  }
1456 
1457  {
1458  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
1459  if (it != kvmap.end()) {
1460  it->second->convert(a9);
1461  }
1462  }
1463 
1464  {
1465  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
1466  if (it != kvmap.end()) {
1467  it->second->convert(a11);
1468  }
1469  }
1470 
1471  {
1472  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
1473  if (it != kvmap.end()) {
1474  it->second->convert(a13);
1475  }
1476  }
1477 
1478  {
1479  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
1480  if (it != kvmap.end()) {
1481  it->second->convert(a15);
1482  }
1483  }
1484 
1485  {
1486  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
1487  if (it != kvmap.end()) {
1488  it->second->convert(a17);
1489  }
1490  }
1491 
1492  {
1493  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a18);
1494  if (it != kvmap.end()) {
1495  it->second->convert(a19);
1496  }
1497  }
1498 
1499  {
1500  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a20);
1501  if (it != kvmap.end()) {
1502  it->second->convert(a21);
1503  }
1504  }
1505 
1506  {
1507  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a22);
1508  if (it != kvmap.end()) {
1509  it->second->convert(a23);
1510  }
1511  }
1512 
1513  }
1514  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
1515  {
1516  o->type = msgpack::type::MAP;
1517  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*12, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
1518  o->via.map.size = 12;
1519 
1520  o->via.map.ptr[0].key = msgpack::object(a0, z);
1521  o->via.map.ptr[0].val = msgpack::object(a1, z);
1522 
1523  o->via.map.ptr[1].key = msgpack::object(a2, z);
1524  o->via.map.ptr[1].val = msgpack::object(a3, z);
1525 
1526  o->via.map.ptr[2].key = msgpack::object(a4, z);
1527  o->via.map.ptr[2].val = msgpack::object(a5, z);
1528 
1529  o->via.map.ptr[3].key = msgpack::object(a6, z);
1530  o->via.map.ptr[3].val = msgpack::object(a7, z);
1531 
1532  o->via.map.ptr[4].key = msgpack::object(a8, z);
1533  o->via.map.ptr[4].val = msgpack::object(a9, z);
1534 
1535  o->via.map.ptr[5].key = msgpack::object(a10, z);
1536  o->via.map.ptr[5].val = msgpack::object(a11, z);
1537 
1538  o->via.map.ptr[6].key = msgpack::object(a12, z);
1539  o->via.map.ptr[6].val = msgpack::object(a13, z);
1540 
1541  o->via.map.ptr[7].key = msgpack::object(a14, z);
1542  o->via.map.ptr[7].val = msgpack::object(a15, z);
1543 
1544  o->via.map.ptr[8].key = msgpack::object(a16, z);
1545  o->via.map.ptr[8].val = msgpack::object(a17, z);
1546 
1547  o->via.map.ptr[9].key = msgpack::object(a18, z);
1548  o->via.map.ptr[9].val = msgpack::object(a19, z);
1549 
1550  o->via.map.ptr[10].key = msgpack::object(a20, z);
1551  o->via.map.ptr[10].val = msgpack::object(a21, z);
1552 
1553  o->via.map.ptr[11].key = msgpack::object(a22, z);
1554  o->via.map.ptr[11].val = msgpack::object(a23, z);
1555 
1556  }
1557 
1558  A0& a0;
1559  A1& a1;
1560  A2& a2;
1561  A3& a3;
1562  A4& a4;
1563  A5& a5;
1564  A6& a6;
1565  A7& a7;
1566  A8& a8;
1567  A9& a9;
1568  A10& a10;
1569  A11& a11;
1570  A12& a12;
1571  A13& a13;
1572  A14& a14;
1573  A15& a15;
1574  A16& a16;
1575  A17& a17;
1576  A18& a18;
1577  A19& a19;
1578  A20& a20;
1579  A21& a21;
1580  A22& a22;
1581  A23& a23;
1582 };
1583 
1584 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
1585 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> {
1586  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) :
1587  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {}
1588  template <typename Packer>
1589  void msgpack_pack(Packer& pk) const
1590  {
1591  pk.pack_map(13);
1592 
1593  pk.pack(a0);
1594  pk.pack(a1);
1595  pk.pack(a2);
1596  pk.pack(a3);
1597  pk.pack(a4);
1598  pk.pack(a5);
1599  pk.pack(a6);
1600  pk.pack(a7);
1601  pk.pack(a8);
1602  pk.pack(a9);
1603  pk.pack(a10);
1604  pk.pack(a11);
1605  pk.pack(a12);
1606  pk.pack(a13);
1607  pk.pack(a14);
1608  pk.pack(a15);
1609  pk.pack(a16);
1610  pk.pack(a17);
1611  pk.pack(a18);
1612  pk.pack(a19);
1613  pk.pack(a20);
1614  pk.pack(a21);
1615  pk.pack(a22);
1616  pk.pack(a23);
1617  pk.pack(a24);
1618  pk.pack(a25);
1619  }
1620  void msgpack_unpack(msgpack::object const& o) const
1621  {
1622  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
1623  std::map<std::string, msgpack::object const*> kvmap;
1624  for (uint32_t i = 0; i < o.via.map.size; ++i) {
1625  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
1626  kvmap.insert(
1627  std::map<std::string, msgpack::object const*>::value_type(
1628  std::string(
1629  o.via.map.ptr[i].key.via.str.ptr,
1630  o.via.map.ptr[i].key.via.str.size),
1631  &o.via.map.ptr[i].val
1632  )
1633  );
1634  }
1635 
1636  {
1637  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
1638  if (it != kvmap.end()) {
1639  it->second->convert(a1);
1640  }
1641  }
1642 
1643  {
1644  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
1645  if (it != kvmap.end()) {
1646  it->second->convert(a3);
1647  }
1648  }
1649 
1650  {
1651  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
1652  if (it != kvmap.end()) {
1653  it->second->convert(a5);
1654  }
1655  }
1656 
1657  {
1658  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
1659  if (it != kvmap.end()) {
1660  it->second->convert(a7);
1661  }
1662  }
1663 
1664  {
1665  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
1666  if (it != kvmap.end()) {
1667  it->second->convert(a9);
1668  }
1669  }
1670 
1671  {
1672  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
1673  if (it != kvmap.end()) {
1674  it->second->convert(a11);
1675  }
1676  }
1677 
1678  {
1679  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
1680  if (it != kvmap.end()) {
1681  it->second->convert(a13);
1682  }
1683  }
1684 
1685  {
1686  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
1687  if (it != kvmap.end()) {
1688  it->second->convert(a15);
1689  }
1690  }
1691 
1692  {
1693  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
1694  if (it != kvmap.end()) {
1695  it->second->convert(a17);
1696  }
1697  }
1698 
1699  {
1700  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a18);
1701  if (it != kvmap.end()) {
1702  it->second->convert(a19);
1703  }
1704  }
1705 
1706  {
1707  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a20);
1708  if (it != kvmap.end()) {
1709  it->second->convert(a21);
1710  }
1711  }
1712 
1713  {
1714  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a22);
1715  if (it != kvmap.end()) {
1716  it->second->convert(a23);
1717  }
1718  }
1719 
1720  {
1721  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a24);
1722  if (it != kvmap.end()) {
1723  it->second->convert(a25);
1724  }
1725  }
1726 
1727  }
1728  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
1729  {
1730  o->type = msgpack::type::MAP;
1731  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*13, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
1732  o->via.map.size = 13;
1733 
1734  o->via.map.ptr[0].key = msgpack::object(a0, z);
1735  o->via.map.ptr[0].val = msgpack::object(a1, z);
1736 
1737  o->via.map.ptr[1].key = msgpack::object(a2, z);
1738  o->via.map.ptr[1].val = msgpack::object(a3, z);
1739 
1740  o->via.map.ptr[2].key = msgpack::object(a4, z);
1741  o->via.map.ptr[2].val = msgpack::object(a5, z);
1742 
1743  o->via.map.ptr[3].key = msgpack::object(a6, z);
1744  o->via.map.ptr[3].val = msgpack::object(a7, z);
1745 
1746  o->via.map.ptr[4].key = msgpack::object(a8, z);
1747  o->via.map.ptr[4].val = msgpack::object(a9, z);
1748 
1749  o->via.map.ptr[5].key = msgpack::object(a10, z);
1750  o->via.map.ptr[5].val = msgpack::object(a11, z);
1751 
1752  o->via.map.ptr[6].key = msgpack::object(a12, z);
1753  o->via.map.ptr[6].val = msgpack::object(a13, z);
1754 
1755  o->via.map.ptr[7].key = msgpack::object(a14, z);
1756  o->via.map.ptr[7].val = msgpack::object(a15, z);
1757 
1758  o->via.map.ptr[8].key = msgpack::object(a16, z);
1759  o->via.map.ptr[8].val = msgpack::object(a17, z);
1760 
1761  o->via.map.ptr[9].key = msgpack::object(a18, z);
1762  o->via.map.ptr[9].val = msgpack::object(a19, z);
1763 
1764  o->via.map.ptr[10].key = msgpack::object(a20, z);
1765  o->via.map.ptr[10].val = msgpack::object(a21, z);
1766 
1767  o->via.map.ptr[11].key = msgpack::object(a22, z);
1768  o->via.map.ptr[11].val = msgpack::object(a23, z);
1769 
1770  o->via.map.ptr[12].key = msgpack::object(a24, z);
1771  o->via.map.ptr[12].val = msgpack::object(a25, z);
1772 
1773  }
1774 
1775  A0& a0;
1776  A1& a1;
1777  A2& a2;
1778  A3& a3;
1779  A4& a4;
1780  A5& a5;
1781  A6& a6;
1782  A7& a7;
1783  A8& a8;
1784  A9& a9;
1785  A10& a10;
1786  A11& a11;
1787  A12& a12;
1788  A13& a13;
1789  A14& a14;
1790  A15& a15;
1791  A16& a16;
1792  A17& a17;
1793  A18& a18;
1794  A19& a19;
1795  A20& a20;
1796  A21& a21;
1797  A22& a22;
1798  A23& a23;
1799  A24& a24;
1800  A25& a25;
1801 };
1802 
1803 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
1804 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> {
1805  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) :
1806  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {}
1807  template <typename Packer>
1808  void msgpack_pack(Packer& pk) const
1809  {
1810  pk.pack_map(14);
1811 
1812  pk.pack(a0);
1813  pk.pack(a1);
1814  pk.pack(a2);
1815  pk.pack(a3);
1816  pk.pack(a4);
1817  pk.pack(a5);
1818  pk.pack(a6);
1819  pk.pack(a7);
1820  pk.pack(a8);
1821  pk.pack(a9);
1822  pk.pack(a10);
1823  pk.pack(a11);
1824  pk.pack(a12);
1825  pk.pack(a13);
1826  pk.pack(a14);
1827  pk.pack(a15);
1828  pk.pack(a16);
1829  pk.pack(a17);
1830  pk.pack(a18);
1831  pk.pack(a19);
1832  pk.pack(a20);
1833  pk.pack(a21);
1834  pk.pack(a22);
1835  pk.pack(a23);
1836  pk.pack(a24);
1837  pk.pack(a25);
1838  pk.pack(a26);
1839  pk.pack(a27);
1840  }
1841  void msgpack_unpack(msgpack::object const& o) const
1842  {
1843  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
1844  std::map<std::string, msgpack::object const*> kvmap;
1845  for (uint32_t i = 0; i < o.via.map.size; ++i) {
1846  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
1847  kvmap.insert(
1848  std::map<std::string, msgpack::object const*>::value_type(
1849  std::string(
1850  o.via.map.ptr[i].key.via.str.ptr,
1851  o.via.map.ptr[i].key.via.str.size),
1852  &o.via.map.ptr[i].val
1853  )
1854  );
1855  }
1856 
1857  {
1858  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
1859  if (it != kvmap.end()) {
1860  it->second->convert(a1);
1861  }
1862  }
1863 
1864  {
1865  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
1866  if (it != kvmap.end()) {
1867  it->second->convert(a3);
1868  }
1869  }
1870 
1871  {
1872  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
1873  if (it != kvmap.end()) {
1874  it->second->convert(a5);
1875  }
1876  }
1877 
1878  {
1879  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
1880  if (it != kvmap.end()) {
1881  it->second->convert(a7);
1882  }
1883  }
1884 
1885  {
1886  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
1887  if (it != kvmap.end()) {
1888  it->second->convert(a9);
1889  }
1890  }
1891 
1892  {
1893  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
1894  if (it != kvmap.end()) {
1895  it->second->convert(a11);
1896  }
1897  }
1898 
1899  {
1900  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
1901  if (it != kvmap.end()) {
1902  it->second->convert(a13);
1903  }
1904  }
1905 
1906  {
1907  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
1908  if (it != kvmap.end()) {
1909  it->second->convert(a15);
1910  }
1911  }
1912 
1913  {
1914  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
1915  if (it != kvmap.end()) {
1916  it->second->convert(a17);
1917  }
1918  }
1919 
1920  {
1921  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a18);
1922  if (it != kvmap.end()) {
1923  it->second->convert(a19);
1924  }
1925  }
1926 
1927  {
1928  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a20);
1929  if (it != kvmap.end()) {
1930  it->second->convert(a21);
1931  }
1932  }
1933 
1934  {
1935  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a22);
1936  if (it != kvmap.end()) {
1937  it->second->convert(a23);
1938  }
1939  }
1940 
1941  {
1942  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a24);
1943  if (it != kvmap.end()) {
1944  it->second->convert(a25);
1945  }
1946  }
1947 
1948  {
1949  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a26);
1950  if (it != kvmap.end()) {
1951  it->second->convert(a27);
1952  }
1953  }
1954 
1955  }
1956  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
1957  {
1958  o->type = msgpack::type::MAP;
1959  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*14, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
1960  o->via.map.size = 14;
1961 
1962  o->via.map.ptr[0].key = msgpack::object(a0, z);
1963  o->via.map.ptr[0].val = msgpack::object(a1, z);
1964 
1965  o->via.map.ptr[1].key = msgpack::object(a2, z);
1966  o->via.map.ptr[1].val = msgpack::object(a3, z);
1967 
1968  o->via.map.ptr[2].key = msgpack::object(a4, z);
1969  o->via.map.ptr[2].val = msgpack::object(a5, z);
1970 
1971  o->via.map.ptr[3].key = msgpack::object(a6, z);
1972  o->via.map.ptr[3].val = msgpack::object(a7, z);
1973 
1974  o->via.map.ptr[4].key = msgpack::object(a8, z);
1975  o->via.map.ptr[4].val = msgpack::object(a9, z);
1976 
1977  o->via.map.ptr[5].key = msgpack::object(a10, z);
1978  o->via.map.ptr[5].val = msgpack::object(a11, z);
1979 
1980  o->via.map.ptr[6].key = msgpack::object(a12, z);
1981  o->via.map.ptr[6].val = msgpack::object(a13, z);
1982 
1983  o->via.map.ptr[7].key = msgpack::object(a14, z);
1984  o->via.map.ptr[7].val = msgpack::object(a15, z);
1985 
1986  o->via.map.ptr[8].key = msgpack::object(a16, z);
1987  o->via.map.ptr[8].val = msgpack::object(a17, z);
1988 
1989  o->via.map.ptr[9].key = msgpack::object(a18, z);
1990  o->via.map.ptr[9].val = msgpack::object(a19, z);
1991 
1992  o->via.map.ptr[10].key = msgpack::object(a20, z);
1993  o->via.map.ptr[10].val = msgpack::object(a21, z);
1994 
1995  o->via.map.ptr[11].key = msgpack::object(a22, z);
1996  o->via.map.ptr[11].val = msgpack::object(a23, z);
1997 
1998  o->via.map.ptr[12].key = msgpack::object(a24, z);
1999  o->via.map.ptr[12].val = msgpack::object(a25, z);
2000 
2001  o->via.map.ptr[13].key = msgpack::object(a26, z);
2002  o->via.map.ptr[13].val = msgpack::object(a27, z);
2003 
2004  }
2005 
2006  A0& a0;
2007  A1& a1;
2008  A2& a2;
2009  A3& a3;
2010  A4& a4;
2011  A5& a5;
2012  A6& a6;
2013  A7& a7;
2014  A8& a8;
2015  A9& a9;
2016  A10& a10;
2017  A11& a11;
2018  A12& a12;
2019  A13& a13;
2020  A14& a14;
2021  A15& a15;
2022  A16& a16;
2023  A17& a17;
2024  A18& a18;
2025  A19& a19;
2026  A20& a20;
2027  A21& a21;
2028  A22& a22;
2029  A23& a23;
2030  A24& a24;
2031  A25& a25;
2032  A26& a26;
2033  A27& a27;
2034 };
2035 
2036 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
2037 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> {
2038  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) :
2039  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {}
2040  template <typename Packer>
2041  void msgpack_pack(Packer& pk) const
2042  {
2043  pk.pack_map(15);
2044 
2045  pk.pack(a0);
2046  pk.pack(a1);
2047  pk.pack(a2);
2048  pk.pack(a3);
2049  pk.pack(a4);
2050  pk.pack(a5);
2051  pk.pack(a6);
2052  pk.pack(a7);
2053  pk.pack(a8);
2054  pk.pack(a9);
2055  pk.pack(a10);
2056  pk.pack(a11);
2057  pk.pack(a12);
2058  pk.pack(a13);
2059  pk.pack(a14);
2060  pk.pack(a15);
2061  pk.pack(a16);
2062  pk.pack(a17);
2063  pk.pack(a18);
2064  pk.pack(a19);
2065  pk.pack(a20);
2066  pk.pack(a21);
2067  pk.pack(a22);
2068  pk.pack(a23);
2069  pk.pack(a24);
2070  pk.pack(a25);
2071  pk.pack(a26);
2072  pk.pack(a27);
2073  pk.pack(a28);
2074  pk.pack(a29);
2075  }
2076  void msgpack_unpack(msgpack::object const& o) const
2077  {
2078  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
2079  std::map<std::string, msgpack::object const*> kvmap;
2080  for (uint32_t i = 0; i < o.via.map.size; ++i) {
2081  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
2082  kvmap.insert(
2083  std::map<std::string, msgpack::object const*>::value_type(
2084  std::string(
2085  o.via.map.ptr[i].key.via.str.ptr,
2086  o.via.map.ptr[i].key.via.str.size),
2087  &o.via.map.ptr[i].val
2088  )
2089  );
2090  }
2091 
2092  {
2093  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
2094  if (it != kvmap.end()) {
2095  it->second->convert(a1);
2096  }
2097  }
2098 
2099  {
2100  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
2101  if (it != kvmap.end()) {
2102  it->second->convert(a3);
2103  }
2104  }
2105 
2106  {
2107  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
2108  if (it != kvmap.end()) {
2109  it->second->convert(a5);
2110  }
2111  }
2112 
2113  {
2114  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
2115  if (it != kvmap.end()) {
2116  it->second->convert(a7);
2117  }
2118  }
2119 
2120  {
2121  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
2122  if (it != kvmap.end()) {
2123  it->second->convert(a9);
2124  }
2125  }
2126 
2127  {
2128  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
2129  if (it != kvmap.end()) {
2130  it->second->convert(a11);
2131  }
2132  }
2133 
2134  {
2135  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
2136  if (it != kvmap.end()) {
2137  it->second->convert(a13);
2138  }
2139  }
2140 
2141  {
2142  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
2143  if (it != kvmap.end()) {
2144  it->second->convert(a15);
2145  }
2146  }
2147 
2148  {
2149  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
2150  if (it != kvmap.end()) {
2151  it->second->convert(a17);
2152  }
2153  }
2154 
2155  {
2156  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a18);
2157  if (it != kvmap.end()) {
2158  it->second->convert(a19);
2159  }
2160  }
2161 
2162  {
2163  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a20);
2164  if (it != kvmap.end()) {
2165  it->second->convert(a21);
2166  }
2167  }
2168 
2169  {
2170  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a22);
2171  if (it != kvmap.end()) {
2172  it->second->convert(a23);
2173  }
2174  }
2175 
2176  {
2177  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a24);
2178  if (it != kvmap.end()) {
2179  it->second->convert(a25);
2180  }
2181  }
2182 
2183  {
2184  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a26);
2185  if (it != kvmap.end()) {
2186  it->second->convert(a27);
2187  }
2188  }
2189 
2190  {
2191  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a28);
2192  if (it != kvmap.end()) {
2193  it->second->convert(a29);
2194  }
2195  }
2196 
2197  }
2198  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
2199  {
2200  o->type = msgpack::type::MAP;
2201  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*15, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
2202  o->via.map.size = 15;
2203 
2204  o->via.map.ptr[0].key = msgpack::object(a0, z);
2205  o->via.map.ptr[0].val = msgpack::object(a1, z);
2206 
2207  o->via.map.ptr[1].key = msgpack::object(a2, z);
2208  o->via.map.ptr[1].val = msgpack::object(a3, z);
2209 
2210  o->via.map.ptr[2].key = msgpack::object(a4, z);
2211  o->via.map.ptr[2].val = msgpack::object(a5, z);
2212 
2213  o->via.map.ptr[3].key = msgpack::object(a6, z);
2214  o->via.map.ptr[3].val = msgpack::object(a7, z);
2215 
2216  o->via.map.ptr[4].key = msgpack::object(a8, z);
2217  o->via.map.ptr[4].val = msgpack::object(a9, z);
2218 
2219  o->via.map.ptr[5].key = msgpack::object(a10, z);
2220  o->via.map.ptr[5].val = msgpack::object(a11, z);
2221 
2222  o->via.map.ptr[6].key = msgpack::object(a12, z);
2223  o->via.map.ptr[6].val = msgpack::object(a13, z);
2224 
2225  o->via.map.ptr[7].key = msgpack::object(a14, z);
2226  o->via.map.ptr[7].val = msgpack::object(a15, z);
2227 
2228  o->via.map.ptr[8].key = msgpack::object(a16, z);
2229  o->via.map.ptr[8].val = msgpack::object(a17, z);
2230 
2231  o->via.map.ptr[9].key = msgpack::object(a18, z);
2232  o->via.map.ptr[9].val = msgpack::object(a19, z);
2233 
2234  o->via.map.ptr[10].key = msgpack::object(a20, z);
2235  o->via.map.ptr[10].val = msgpack::object(a21, z);
2236 
2237  o->via.map.ptr[11].key = msgpack::object(a22, z);
2238  o->via.map.ptr[11].val = msgpack::object(a23, z);
2239 
2240  o->via.map.ptr[12].key = msgpack::object(a24, z);
2241  o->via.map.ptr[12].val = msgpack::object(a25, z);
2242 
2243  o->via.map.ptr[13].key = msgpack::object(a26, z);
2244  o->via.map.ptr[13].val = msgpack::object(a27, z);
2245 
2246  o->via.map.ptr[14].key = msgpack::object(a28, z);
2247  o->via.map.ptr[14].val = msgpack::object(a29, z);
2248 
2249  }
2250 
2251  A0& a0;
2252  A1& a1;
2253  A2& a2;
2254  A3& a3;
2255  A4& a4;
2256  A5& a5;
2257  A6& a6;
2258  A7& a7;
2259  A8& a8;
2260  A9& a9;
2261  A10& a10;
2262  A11& a11;
2263  A12& a12;
2264  A13& a13;
2265  A14& a14;
2266  A15& a15;
2267  A16& a16;
2268  A17& a17;
2269  A18& a18;
2270  A19& a19;
2271  A20& a20;
2272  A21& a21;
2273  A22& a22;
2274  A23& a23;
2275  A24& a24;
2276  A25& a25;
2277  A26& a26;
2278  A27& a27;
2279  A28& a28;
2280  A29& a29;
2281 };
2282 
2283 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
2284 struct define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> {
2285  define_map(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) :
2286  a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {}
2287  template <typename Packer>
2288  void msgpack_pack(Packer& pk) const
2289  {
2290  pk.pack_map(16);
2291 
2292  pk.pack(a0);
2293  pk.pack(a1);
2294  pk.pack(a2);
2295  pk.pack(a3);
2296  pk.pack(a4);
2297  pk.pack(a5);
2298  pk.pack(a6);
2299  pk.pack(a7);
2300  pk.pack(a8);
2301  pk.pack(a9);
2302  pk.pack(a10);
2303  pk.pack(a11);
2304  pk.pack(a12);
2305  pk.pack(a13);
2306  pk.pack(a14);
2307  pk.pack(a15);
2308  pk.pack(a16);
2309  pk.pack(a17);
2310  pk.pack(a18);
2311  pk.pack(a19);
2312  pk.pack(a20);
2313  pk.pack(a21);
2314  pk.pack(a22);
2315  pk.pack(a23);
2316  pk.pack(a24);
2317  pk.pack(a25);
2318  pk.pack(a26);
2319  pk.pack(a27);
2320  pk.pack(a28);
2321  pk.pack(a29);
2322  pk.pack(a30);
2323  pk.pack(a31);
2324  }
2325  void msgpack_unpack(msgpack::object const& o) const
2326  {
2327  if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); }
2328  std::map<std::string, msgpack::object const*> kvmap;
2329  for (uint32_t i = 0; i < o.via.map.size; ++i) {
2330  if (o.via.map.ptr[i].key.type != msgpack::type::STR) { throw msgpack::type_error(); }
2331  kvmap.insert(
2332  std::map<std::string, msgpack::object const*>::value_type(
2333  std::string(
2334  o.via.map.ptr[i].key.via.str.ptr,
2335  o.via.map.ptr[i].key.via.str.size),
2336  &o.via.map.ptr[i].val
2337  )
2338  );
2339  }
2340 
2341  {
2342  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a0);
2343  if (it != kvmap.end()) {
2344  it->second->convert(a1);
2345  }
2346  }
2347 
2348  {
2349  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a2);
2350  if (it != kvmap.end()) {
2351  it->second->convert(a3);
2352  }
2353  }
2354 
2355  {
2356  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a4);
2357  if (it != kvmap.end()) {
2358  it->second->convert(a5);
2359  }
2360  }
2361 
2362  {
2363  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a6);
2364  if (it != kvmap.end()) {
2365  it->second->convert(a7);
2366  }
2367  }
2368 
2369  {
2370  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a8);
2371  if (it != kvmap.end()) {
2372  it->second->convert(a9);
2373  }
2374  }
2375 
2376  {
2377  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a10);
2378  if (it != kvmap.end()) {
2379  it->second->convert(a11);
2380  }
2381  }
2382 
2383  {
2384  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a12);
2385  if (it != kvmap.end()) {
2386  it->second->convert(a13);
2387  }
2388  }
2389 
2390  {
2391  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a14);
2392  if (it != kvmap.end()) {
2393  it->second->convert(a15);
2394  }
2395  }
2396 
2397  {
2398  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a16);
2399  if (it != kvmap.end()) {
2400  it->second->convert(a17);
2401  }
2402  }
2403 
2404  {
2405  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a18);
2406  if (it != kvmap.end()) {
2407  it->second->convert(a19);
2408  }
2409  }
2410 
2411  {
2412  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a20);
2413  if (it != kvmap.end()) {
2414  it->second->convert(a21);
2415  }
2416  }
2417 
2418  {
2419  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a22);
2420  if (it != kvmap.end()) {
2421  it->second->convert(a23);
2422  }
2423  }
2424 
2425  {
2426  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a24);
2427  if (it != kvmap.end()) {
2428  it->second->convert(a25);
2429  }
2430  }
2431 
2432  {
2433  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a26);
2434  if (it != kvmap.end()) {
2435  it->second->convert(a27);
2436  }
2437  }
2438 
2439  {
2440  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a28);
2441  if (it != kvmap.end()) {
2442  it->second->convert(a29);
2443  }
2444  }
2445 
2446  {
2447  std::map<std::string, msgpack::object const*>::const_iterator it = kvmap.find(a30);
2448  if (it != kvmap.end()) {
2449  it->second->convert(a31);
2450  }
2451  }
2452 
2453  }
2454  void msgpack_object(msgpack::object* o, msgpack::zone& z) const
2455  {
2456  o->type = msgpack::type::MAP;
2457  o->via.map.ptr = static_cast<msgpack::object_kv*>(z.allocate_align(sizeof(msgpack::object_kv)*16, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
2458  o->via.map.size = 16;
2459 
2460  o->via.map.ptr[0].key = msgpack::object(a0, z);
2461  o->via.map.ptr[0].val = msgpack::object(a1, z);
2462 
2463  o->via.map.ptr[1].key = msgpack::object(a2, z);
2464  o->via.map.ptr[1].val = msgpack::object(a3, z);
2465 
2466  o->via.map.ptr[2].key = msgpack::object(a4, z);
2467  o->via.map.ptr[2].val = msgpack::object(a5, z);
2468 
2469  o->via.map.ptr[3].key = msgpack::object(a6, z);
2470  o->via.map.ptr[3].val = msgpack::object(a7, z);
2471 
2472  o->via.map.ptr[4].key = msgpack::object(a8, z);
2473  o->via.map.ptr[4].val = msgpack::object(a9, z);
2474 
2475  o->via.map.ptr[5].key = msgpack::object(a10, z);
2476  o->via.map.ptr[5].val = msgpack::object(a11, z);
2477 
2478  o->via.map.ptr[6].key = msgpack::object(a12, z);
2479  o->via.map.ptr[6].val = msgpack::object(a13, z);
2480 
2481  o->via.map.ptr[7].key = msgpack::object(a14, z);
2482  o->via.map.ptr[7].val = msgpack::object(a15, z);
2483 
2484  o->via.map.ptr[8].key = msgpack::object(a16, z);
2485  o->via.map.ptr[8].val = msgpack::object(a17, z);
2486 
2487  o->via.map.ptr[9].key = msgpack::object(a18, z);
2488  o->via.map.ptr[9].val = msgpack::object(a19, z);
2489 
2490  o->via.map.ptr[10].key = msgpack::object(a20, z);
2491  o->via.map.ptr[10].val = msgpack::object(a21, z);
2492 
2493  o->via.map.ptr[11].key = msgpack::object(a22, z);
2494  o->via.map.ptr[11].val = msgpack::object(a23, z);
2495 
2496  o->via.map.ptr[12].key = msgpack::object(a24, z);
2497  o->via.map.ptr[12].val = msgpack::object(a25, z);
2498 
2499  o->via.map.ptr[13].key = msgpack::object(a26, z);
2500  o->via.map.ptr[13].val = msgpack::object(a27, z);
2501 
2502  o->via.map.ptr[14].key = msgpack::object(a28, z);
2503  o->via.map.ptr[14].val = msgpack::object(a29, z);
2504 
2505  o->via.map.ptr[15].key = msgpack::object(a30, z);
2506  o->via.map.ptr[15].val = msgpack::object(a31, z);
2507 
2508  }
2509 
2510  A0& a0;
2511  A1& a1;
2512  A2& a2;
2513  A3& a3;
2514  A4& a4;
2515  A5& a5;
2516  A6& a6;
2517  A7& a7;
2518  A8& a8;
2519  A9& a9;
2520  A10& a10;
2521  A11& a11;
2522  A12& a12;
2523  A13& a13;
2524  A14& a14;
2525  A15& a15;
2526  A16& a16;
2527  A17& a17;
2528  A18& a18;
2529  A19& a19;
2530  A20& a20;
2531  A21& a21;
2532  A22& a22;
2533  A23& a23;
2534  A24& a24;
2535  A25& a25;
2536  A26& a26;
2537  A27& a27;
2538  A28& a28;
2539  A29& a29;
2540  A30& a30;
2541  A31& a31;
2542 };
2543 
2545 
2546 inline define_map<> make_define_map()
2547 {
2548  return define_map<>();
2549 }
2550 
2552 
2553 template <typename A0>
2554 inline define_map<A0> make_define_map(A0& a0)
2555 {
2556  return define_map<A0>(a0);
2557 }
2558 
2559 template <typename A0, typename A1>
2560 inline define_map<A0, A1> make_define_map(A0& a0, A1& a1)
2561 {
2562  return define_map<A0, A1>(a0, a1);
2563 }
2564 
2565 template <typename A0, typename A1, typename A2>
2566 inline define_map<A0, A1, A2> make_define_map(A0& a0, A1& a1, A2& a2)
2567 {
2568  return define_map<A0, A1, A2>(a0, a1, a2);
2569 }
2570 
2571 template <typename A0, typename A1, typename A2, typename A3>
2572 inline define_map<A0, A1, A2, A3> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3)
2573 {
2574  return define_map<A0, A1, A2, A3>(a0, a1, a2, a3);
2575 }
2576 
2577 template <typename A0, typename A1, typename A2, typename A3, typename A4>
2578 inline define_map<A0, A1, A2, A3, A4> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4)
2579 {
2580  return define_map<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4);
2581 }
2582 
2583 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5>
2584 inline define_map<A0, A1, A2, A3, A4, A5> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5)
2585 {
2586  return define_map<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5);
2587 }
2588 
2589 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
2590 inline define_map<A0, A1, A2, A3, A4, A5, A6> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6)
2591 {
2592  return define_map<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6);
2593 }
2594 
2595 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
2596 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7)
2597 {
2598  return define_map<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7);
2599 }
2600 
2601 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
2602 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8)
2603 {
2604  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8);
2605 }
2606 
2607 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
2608 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9)
2609 {
2610  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
2611 }
2612 
2613 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
2614 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10)
2615 {
2616  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
2617 }
2618 
2619 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
2620 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11)
2621 {
2622  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
2623 }
2624 
2625 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
2626 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12)
2627 {
2628  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
2629 }
2630 
2631 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13>
2632 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13)
2633 {
2634  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
2635 }
2636 
2637 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14>
2638 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14)
2639 {
2640  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
2641 }
2642 
2643 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15>
2644 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15)
2645 {
2646  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
2647 }
2648 
2649 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16>
2650 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16)
2651 {
2652  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
2653 }
2654 
2655 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17>
2656 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17)
2657 {
2658  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
2659 }
2660 
2661 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18>
2662 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18)
2663 {
2664  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);
2665 }
2666 
2667 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19>
2668 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19)
2669 {
2670  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
2671 }
2672 
2673 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20>
2674 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20)
2675 {
2676  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
2677 }
2678 
2679 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21>
2680 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21)
2681 {
2682  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21);
2683 }
2684 
2685 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22>
2686 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22)
2687 {
2688  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22);
2689 }
2690 
2691 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23>
2692 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23)
2693 {
2694  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23);
2695 }
2696 
2697 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24>
2698 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24)
2699 {
2700  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24);
2701 }
2702 
2703 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25>
2704 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25)
2705 {
2706  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25);
2707 }
2708 
2709 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26>
2710 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26)
2711 {
2712  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26);
2713 }
2714 
2715 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27>
2716 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27)
2717 {
2718  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27);
2719 }
2720 
2721 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28>
2722 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28)
2723 {
2724  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28);
2725 }
2726 
2727 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29>
2728 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29)
2729 {
2730  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29);
2731 }
2732 
2733 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30>
2734 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30)
2735 {
2736  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30);
2737 }
2738 
2739 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12, typename A13, typename A14, typename A15, typename A16, typename A17, typename A18, typename A19, typename A20, typename A21, typename A22, typename A23, typename A24, typename A25, typename A26, typename A27, typename A28, typename A29, typename A30, typename A31>
2740 inline define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31> make_define_map(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31)
2741 {
2742  return define_map<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31);
2743 }
2744 
2746 
2747 } // namespace type
2749 } // MSGPACK_API_VERSION_NAMESPACE(v1)
2751 } // namespace msgpack
2752 
2753 #endif // MSGPACK_V1_CPP03_DEFINE_MAP_HPP
adaptor_base.hpp
msgpack_tuple.hpp
msgpack::type_error
Definition: object_fwd.hpp:231
msgpack::zone
Definition: cpp03_zone.hpp:31
msgpack::zone::allocate_align
void * allocate_align(size_t size, size_t align=MSGPACK_ZONE_ALIGN)
Definition: cpp03_zone.hpp:256
msgpack::type::MAP
@ MAP
Definition: object_fwd_decl.hpp:41
msgpack::type::STR
@ STR
Definition: object_fwd_decl.hpp:38
msgpack::type::make_define_map
define_map make_define_map()
Definition: cpp03_define_map.hpp:2546
msgpack
Definition: adaptor_base.hpp:15
object_fwd.hpp
msgpack::object_kv
Definition: object.hpp:30
msgpack::object_kv::val
msgpack::object val
Definition: object.hpp:32
msgpack::object_kv::key
msgpack::object key
Definition: object.hpp:31
msgpack::object_map::size
uint32_t size
Definition: object_fwd.hpp:28
msgpack::object_map::ptr
msgpack::object_kv * ptr
Definition: object_fwd.hpp:29
msgpack::object_str::ptr
const char * ptr
Definition: object_fwd.hpp:34
msgpack::object_str::size
uint32_t size
Definition: object_fwd.hpp:33
msgpack::object
Object class that corresponding to MessagePack format object.
Definition: object_fwd.hpp:75
msgpack::object::via
union_type via
Definition: object_fwd.hpp:93
msgpack::object::type
msgpack::type::object_type type
Definition: object_fwd.hpp:92
msgpack::type::define_map<>
Definition: cpp03_define_map.hpp:28
msgpack::type::define_map<>::msgpack_pack
void msgpack_pack(Packer &pk) const
Definition: cpp03_define_map.hpp:30
msgpack::type::define_map<>::msgpack_unpack
void msgpack_unpack(msgpack::object const &o) const
Definition: cpp03_define_map.hpp:34
msgpack::type::define_map<>::msgpack_object
void msgpack_object(msgpack::object *o, msgpack::zone &) const
Definition: cpp03_define_map.hpp:38
msgpack::type::define_map
Definition: cpp11_define_map.hpp:59
msgpack::type::define_map::msgpack_unpack
void msgpack_unpack(msgpack::object const &o) const
Definition: cpp11_define_map.hpp:70
msgpack::type::define_map::define_map
define_map(Args &... args)
Definition: cpp11_define_map.hpp:60
msgpack::type::define_map::msgpack_pack
void msgpack_pack(Packer &pk) const
Definition: cpp11_define_map.hpp:63
msgpack::type::define_map::msgpack_object
void msgpack_object(msgpack::object *o, msgpack::zone &z) const
Definition: cpp11_define_map.hpp:84
msgpack::object::union_type::str
msgpack::object_str str
Definition: object_fwd.hpp:87
msgpack::object::union_type::map
msgpack::object_map map
Definition: object_fwd.hpp:86
cpp03_define_map_decl.hpp
MSGPACK_NULLPTR
#define MSGPACK_NULLPTR
Definition: cpp_config_decl.hpp:85
MSGPACK_ZONE_ALIGNOF
#define MSGPACK_ZONE_ALIGNOF(type)
Definition: cpp03_zone_decl.hpp:30
MSGPACK_API_VERSION_NAMESPACE
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:66
Generated by doxygen 1.9.1