Hideaki Tai
messagepack implementation for embedded systems (mbed / arduino)
Dependents: hello_message_pack
Embed:
(wiki syntax)
Show/hide line numbers
cpp03_define_array.hpp
00001 // 00002 // MessagePack for C++ static resolution routine 00003 // 00004 // Copyright (C) 2008-2009 FURUHASHI Sadayuki 00005 // 00006 // Distributed under the Boost Software License, Version 1.0. 00007 // (See accompanying file LICENSE_1_0.txt or copy at 00008 // http://www.boost.org/LICENSE_1_0.txt) 00009 // 00010 #ifndef MSGPACK_CPP03_DEFINE_ARRAY_HPP 00011 #define MSGPACK_CPP03_DEFINE_ARRAY_HPP 00012 00013 #include "msgpack/versioning.hpp" 00014 #include "msgpack/adaptor/msgpack_tuple.hpp" 00015 #include "msgpack/adaptor/adaptor_base.hpp" 00016 #include "msgpack/object_fwd.hpp" 00017 00018 #define MSGPACK_DEFINE_ARRAY(...) \ 00019 template <typename Packer> \ 00020 void msgpack_pack(Packer& pk) const \ 00021 { \ 00022 msgpack::type::make_define_array(__VA_ARGS__).msgpack_pack(pk); \ 00023 } \ 00024 void msgpack_unpack(msgpack::object const& o) \ 00025 { \ 00026 msgpack::type::make_define_array(__VA_ARGS__).msgpack_unpack(o); \ 00027 }\ 00028 template <typename MSGPACK_OBJECT> \ 00029 void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ 00030 { \ 00031 msgpack::type::make_define_array(__VA_ARGS__).msgpack_object(o, z); \ 00032 } 00033 00034 #define MSGPACK_BASE_ARRAY(base) (*const_cast<base *>(static_cast<base const*>(this))) 00035 00036 // MSGPACK_ADD_ENUM must be used in the global namespace. 00037 #define MSGPACK_ADD_ENUM(enum_name) \ 00038 namespace msgpack { \ 00039 /** @cond */ \ 00040 MSGPACK_API_VERSION_NAMESPACE(v1) { \ 00041 /** @endcond */ \ 00042 namespace adaptor { \ 00043 template<> \ 00044 struct convert<enum_name> { \ 00045 msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const {\ 00046 int tmp; \ 00047 o >> tmp; \ 00048 v = static_cast<enum_name>(tmp); \ 00049 return o; \ 00050 } \ 00051 }; \ 00052 template<> \ 00053 struct object<enum_name> { \ 00054 void operator()(msgpack::object& o, const enum_name& v) const {\ 00055 o << static_cast<int>(v); \ 00056 } \ 00057 }; \ 00058 template<> \ 00059 struct object_with_zone<enum_name> { \ 00060 void operator()(msgpack::object::with_zone& o, const enum_name& v) const { \ 00061 o << static_cast<int>(v); \ 00062 } \ 00063 }; \ 00064 template<> \ 00065 struct pack<enum_name> { \ 00066 template <typename Stream> \ 00067 msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const enum_name& v) const { \ 00068 return o << static_cast<int>(v); \ 00069 } \ 00070 }; \ 00071 } \ 00072 /** @cond */ \ 00073 } \ 00074 /** @endcond */ \ 00075 } 00076 00077 namespace msgpack { 00078 /// @cond 00079 MSGPACK_API_VERSION_NAMESPACE(v1) { 00080 /// @endcond 00081 namespace type { 00082 00083 /// @cond 00084 00085 template <typename A0 = void, typename A1 = void, typename A2 = void, typename A3 = void, typename A4 = void, typename A5 = void, typename A6 = void, typename A7 = void, typename A8 = void, typename A9 = void, typename A10 = void, typename A11 = void, typename A12 = void, typename A13 = void, typename A14 = void, typename A15 = void, typename A16 = void, typename A17 = void, typename A18 = void, typename A19 = void, typename A20 = void, typename A21 = void, typename A22 = void, typename A23 = void, typename A24 = void, typename A25 = void, typename A26 = void, typename A27 = void, typename A28 = void, typename A29 = void, typename A30 = void, typename A31 = void, typename A32 = void> 00086 struct define_array; 00087 /// @endcond 00088 00089 template <> 00090 struct define_array<> { 00091 typedef define_array<> value_type; 00092 typedef tuple<> tuple_type; 00093 template <typename Packer> 00094 void msgpack_pack(Packer& pk) const 00095 { 00096 pk.pack_array(0); 00097 } 00098 void msgpack_unpack(msgpack::object const& o) 00099 { 00100 if(o.type != msgpack::type::ARRAY) { 00101 // throw msgpack::type_error(); 00102 } 00103 } 00104 void msgpack_object(msgpack::object* o, msgpack::zone&) const 00105 { 00106 o->type = msgpack::type::ARRAY; 00107 o->via.array.ptr = nullptr; 00108 o->via.array.size = 0; 00109 } 00110 }; 00111 00112 /// @cond 00113 00114 template <typename A0> 00115 struct define_array<A0> { 00116 typedef define_array<A0> value_type; 00117 typedef tuple<A0> tuple_type; 00118 define_array(A0& _a0) : 00119 a0(_a0) {} 00120 template <typename Packer> 00121 void msgpack_pack(Packer& pk) const 00122 { 00123 pk.pack_array(1); 00124 00125 pk.pack(a0); 00126 } 00127 void msgpack_unpack(msgpack::object const& o) 00128 { 00129 if(o.type != msgpack::type::ARRAY) { 00130 printf("throw msgpack::type_error()"); 00131 // throw msgpack::type_error(); 00132 } 00133 const size_t size = o.via.array.size; 00134 if(size > 0) { 00135 msgpack::object *ptr = o.via.array.ptr; 00136 switch(size) { 00137 default: 00138 case 1: ptr[0].convert(a0); 00139 } 00140 } 00141 } 00142 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00143 { 00144 o->type = msgpack::type::ARRAY; 00145 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*1)); 00146 o->via.array.size = 1; 00147 00148 o->via.array.ptr[0] = msgpack::object(a0, z); 00149 } 00150 00151 A0& a0; 00152 }; 00153 00154 template <typename A0, typename A1> 00155 struct define_array<A0, A1> { 00156 typedef define_array<A0, A1> value_type; 00157 typedef tuple<A0, A1> tuple_type; 00158 define_array(A0& _a0, A1& _a1) : 00159 a0(_a0), a1(_a1) {} 00160 template <typename Packer> 00161 void msgpack_pack(Packer& pk) const 00162 { 00163 pk.pack_array(2); 00164 00165 pk.pack(a0); 00166 pk.pack(a1); 00167 } 00168 void msgpack_unpack(msgpack::object const& o) 00169 { 00170 if(o.type != msgpack::type::ARRAY) { 00171 printf("throw msgpack::type_error()"); 00172 // throw msgpack::type_error(); 00173 } 00174 const size_t size = o.via.array.size; 00175 if(size > 0) { 00176 msgpack::object *ptr = o.via.array.ptr; 00177 switch(size) { 00178 default: 00179 case 2: ptr[1].convert(a1); 00180 case 1: ptr[0].convert(a0); 00181 } 00182 } 00183 } 00184 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00185 { 00186 o->type = msgpack::type::ARRAY; 00187 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*2)); 00188 o->via.array.size = 2; 00189 00190 o->via.array.ptr[0] = msgpack::object(a0, z); 00191 o->via.array.ptr[1] = msgpack::object(a1, z); 00192 } 00193 00194 A0& a0; 00195 A1& a1; 00196 }; 00197 00198 template <typename A0, typename A1, typename A2> 00199 struct define_array<A0, A1, A2> { 00200 typedef define_array<A0, A1, A2> value_type; 00201 typedef tuple<A0, A1, A2> tuple_type; 00202 define_array(A0& _a0, A1& _a1, A2& _a2) : 00203 a0(_a0), a1(_a1), a2(_a2) {} 00204 template <typename Packer> 00205 void msgpack_pack(Packer& pk) const 00206 { 00207 pk.pack_array(3); 00208 00209 pk.pack(a0); 00210 pk.pack(a1); 00211 pk.pack(a2); 00212 } 00213 void msgpack_unpack(msgpack::object const& o) 00214 { 00215 if(o.type != msgpack::type::ARRAY) { 00216 printf("throw msgpack::type_error()"); 00217 // throw msgpack::type_error(); 00218 } 00219 const size_t size = o.via.array.size; 00220 if(size > 0) { 00221 msgpack::object *ptr = o.via.array.ptr; 00222 switch(size) { 00223 default: 00224 case 3: ptr[2].convert(a2); 00225 case 2: ptr[1].convert(a1); 00226 case 1: ptr[0].convert(a0); 00227 } 00228 } 00229 } 00230 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00231 { 00232 o->type = msgpack::type::ARRAY; 00233 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*3)); 00234 o->via.array.size = 3; 00235 00236 o->via.array.ptr[0] = msgpack::object(a0, z); 00237 o->via.array.ptr[1] = msgpack::object(a1, z); 00238 o->via.array.ptr[2] = msgpack::object(a2, z); 00239 } 00240 00241 A0& a0; 00242 A1& a1; 00243 A2& a2; 00244 }; 00245 00246 template <typename A0, typename A1, typename A2, typename A3> 00247 struct define_array<A0, A1, A2, A3> { 00248 typedef define_array<A0, A1, A2, A3> value_type; 00249 typedef tuple<A0, A1, A2, A3> tuple_type; 00250 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : 00251 a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} 00252 template <typename Packer> 00253 void msgpack_pack(Packer& pk) const 00254 { 00255 pk.pack_array(4); 00256 00257 pk.pack(a0); 00258 pk.pack(a1); 00259 pk.pack(a2); 00260 pk.pack(a3); 00261 } 00262 void msgpack_unpack(msgpack::object const& o) 00263 { 00264 if(o.type != msgpack::type::ARRAY) { 00265 printf("throw msgpack::type_error()"); 00266 // throw msgpack::type_error(); 00267 } 00268 const size_t size = o.via.array.size; 00269 if(size > 0) { 00270 msgpack::object *ptr = o.via.array.ptr; 00271 switch(size) { 00272 default: 00273 case 4: ptr[3].convert(a3); 00274 case 3: ptr[2].convert(a2); 00275 case 2: ptr[1].convert(a1); 00276 case 1: ptr[0].convert(a0); 00277 } 00278 } 00279 } 00280 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00281 { 00282 o->type = msgpack::type::ARRAY; 00283 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*4)); 00284 o->via.array.size = 4; 00285 00286 o->via.array.ptr[0] = msgpack::object(a0, z); 00287 o->via.array.ptr[1] = msgpack::object(a1, z); 00288 o->via.array.ptr[2] = msgpack::object(a2, z); 00289 o->via.array.ptr[3] = msgpack::object(a3, z); 00290 } 00291 00292 A0& a0; 00293 A1& a1; 00294 A2& a2; 00295 A3& a3; 00296 }; 00297 00298 template <typename A0, typename A1, typename A2, typename A3, typename A4> 00299 struct define_array<A0, A1, A2, A3, A4> { 00300 typedef define_array<A0, A1, A2, A3, A4> value_type; 00301 typedef tuple<A0, A1, A2, A3, A4> tuple_type; 00302 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : 00303 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} 00304 template <typename Packer> 00305 void msgpack_pack(Packer& pk) const 00306 { 00307 pk.pack_array(5); 00308 00309 pk.pack(a0); 00310 pk.pack(a1); 00311 pk.pack(a2); 00312 pk.pack(a3); 00313 pk.pack(a4); 00314 } 00315 void msgpack_unpack(msgpack::object const& o) 00316 { 00317 if(o.type != msgpack::type::ARRAY) { 00318 printf("throw msgpack::type_error()"); 00319 // throw msgpack::type_error(); 00320 } 00321 const size_t size = o.via.array.size; 00322 if(size > 0) { 00323 msgpack::object *ptr = o.via.array.ptr; 00324 switch(size) { 00325 default: 00326 case 5: ptr[4].convert(a4); 00327 case 4: ptr[3].convert(a3); 00328 case 3: ptr[2].convert(a2); 00329 case 2: ptr[1].convert(a1); 00330 case 1: ptr[0].convert(a0); 00331 } 00332 } 00333 } 00334 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00335 { 00336 o->type = msgpack::type::ARRAY; 00337 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*5)); 00338 o->via.array.size = 5; 00339 00340 o->via.array.ptr[0] = msgpack::object(a0, z); 00341 o->via.array.ptr[1] = msgpack::object(a1, z); 00342 o->via.array.ptr[2] = msgpack::object(a2, z); 00343 o->via.array.ptr[3] = msgpack::object(a3, z); 00344 o->via.array.ptr[4] = msgpack::object(a4, z); 00345 } 00346 00347 A0& a0; 00348 A1& a1; 00349 A2& a2; 00350 A3& a3; 00351 A4& a4; 00352 }; 00353 00354 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> 00355 struct define_array<A0, A1, A2, A3, A4, A5> { 00356 typedef define_array<A0, A1, A2, A3, A4, A5> value_type; 00357 typedef tuple<A0, A1, A2, A3, A4, A5> tuple_type; 00358 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) : 00359 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} 00360 template <typename Packer> 00361 void msgpack_pack(Packer& pk) const 00362 { 00363 pk.pack_array(6); 00364 00365 pk.pack(a0); 00366 pk.pack(a1); 00367 pk.pack(a2); 00368 pk.pack(a3); 00369 pk.pack(a4); 00370 pk.pack(a5); 00371 } 00372 void msgpack_unpack(msgpack::object const& o) 00373 { 00374 if(o.type != msgpack::type::ARRAY) { 00375 printf("throw msgpack::type_error()"); 00376 // throw msgpack::type_error(); 00377 } 00378 const size_t size = o.via.array.size; 00379 if(size > 0) { 00380 msgpack::object *ptr = o.via.array.ptr; 00381 switch(size) { 00382 default: 00383 case 6: ptr[5].convert(a5); 00384 case 5: ptr[4].convert(a4); 00385 case 4: ptr[3].convert(a3); 00386 case 3: ptr[2].convert(a2); 00387 case 2: ptr[1].convert(a1); 00388 case 1: ptr[0].convert(a0); 00389 } 00390 } 00391 } 00392 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00393 { 00394 o->type = msgpack::type::ARRAY; 00395 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*6)); 00396 o->via.array.size = 6; 00397 00398 o->via.array.ptr[0] = msgpack::object(a0, z); 00399 o->via.array.ptr[1] = msgpack::object(a1, z); 00400 o->via.array.ptr[2] = msgpack::object(a2, z); 00401 o->via.array.ptr[3] = msgpack::object(a3, z); 00402 o->via.array.ptr[4] = msgpack::object(a4, z); 00403 o->via.array.ptr[5] = msgpack::object(a5, z); 00404 } 00405 00406 A0& a0; 00407 A1& a1; 00408 A2& a2; 00409 A3& a3; 00410 A4& a4; 00411 A5& a5; 00412 }; 00413 00414 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> 00415 struct define_array<A0, A1, A2, A3, A4, A5, A6> { 00416 typedef define_array<A0, A1, A2, A3, A4, A5, A6> value_type; 00417 typedef tuple<A0, A1, A2, A3, A4, A5, A6> tuple_type; 00418 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) : 00419 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} 00420 template <typename Packer> 00421 void msgpack_pack(Packer& pk) const 00422 { 00423 pk.pack_array(7); 00424 00425 pk.pack(a0); 00426 pk.pack(a1); 00427 pk.pack(a2); 00428 pk.pack(a3); 00429 pk.pack(a4); 00430 pk.pack(a5); 00431 pk.pack(a6); 00432 } 00433 void msgpack_unpack(msgpack::object const& o) 00434 { 00435 if(o.type != msgpack::type::ARRAY) { 00436 printf("throw msgpack::type_error()"); 00437 // throw msgpack::type_error(); 00438 } 00439 const size_t size = o.via.array.size; 00440 if(size > 0) { 00441 msgpack::object *ptr = o.via.array.ptr; 00442 switch(size) { 00443 default: 00444 case 7: ptr[6].convert(a6); 00445 case 6: ptr[5].convert(a5); 00446 case 5: ptr[4].convert(a4); 00447 case 4: ptr[3].convert(a3); 00448 case 3: ptr[2].convert(a2); 00449 case 2: ptr[1].convert(a1); 00450 case 1: ptr[0].convert(a0); 00451 } 00452 } 00453 } 00454 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00455 { 00456 o->type = msgpack::type::ARRAY; 00457 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*7)); 00458 o->via.array.size = 7; 00459 00460 o->via.array.ptr[0] = msgpack::object(a0, z); 00461 o->via.array.ptr[1] = msgpack::object(a1, z); 00462 o->via.array.ptr[2] = msgpack::object(a2, z); 00463 o->via.array.ptr[3] = msgpack::object(a3, z); 00464 o->via.array.ptr[4] = msgpack::object(a4, z); 00465 o->via.array.ptr[5] = msgpack::object(a5, z); 00466 o->via.array.ptr[6] = msgpack::object(a6, z); 00467 } 00468 00469 A0& a0; 00470 A1& a1; 00471 A2& a2; 00472 A3& a3; 00473 A4& a4; 00474 A5& a5; 00475 A6& a6; 00476 }; 00477 00478 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> 00479 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7> { 00480 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7> value_type; 00481 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7> tuple_type; 00482 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) : 00483 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} 00484 template <typename Packer> 00485 void msgpack_pack(Packer& pk) const 00486 { 00487 pk.pack_array(8); 00488 00489 pk.pack(a0); 00490 pk.pack(a1); 00491 pk.pack(a2); 00492 pk.pack(a3); 00493 pk.pack(a4); 00494 pk.pack(a5); 00495 pk.pack(a6); 00496 pk.pack(a7); 00497 } 00498 void msgpack_unpack(msgpack::object const& o) 00499 { 00500 if(o.type != msgpack::type::ARRAY) { 00501 printf("throw msgpack::type_error()"); 00502 // throw msgpack::type_error(); 00503 } 00504 const size_t size = o.via.array.size; 00505 if(size > 0) { 00506 msgpack::object *ptr = o.via.array.ptr; 00507 switch(size) { 00508 default: 00509 case 8: ptr[7].convert(a7); 00510 case 7: ptr[6].convert(a6); 00511 case 6: ptr[5].convert(a5); 00512 case 5: ptr[4].convert(a4); 00513 case 4: ptr[3].convert(a3); 00514 case 3: ptr[2].convert(a2); 00515 case 2: ptr[1].convert(a1); 00516 case 1: ptr[0].convert(a0); 00517 } 00518 } 00519 } 00520 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00521 { 00522 o->type = msgpack::type::ARRAY; 00523 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*8)); 00524 o->via.array.size = 8; 00525 00526 o->via.array.ptr[0] = msgpack::object(a0, z); 00527 o->via.array.ptr[1] = msgpack::object(a1, z); 00528 o->via.array.ptr[2] = msgpack::object(a2, z); 00529 o->via.array.ptr[3] = msgpack::object(a3, z); 00530 o->via.array.ptr[4] = msgpack::object(a4, z); 00531 o->via.array.ptr[5] = msgpack::object(a5, z); 00532 o->via.array.ptr[6] = msgpack::object(a6, z); 00533 o->via.array.ptr[7] = msgpack::object(a7, z); 00534 } 00535 00536 A0& a0; 00537 A1& a1; 00538 A2& a2; 00539 A3& a3; 00540 A4& a4; 00541 A5& a5; 00542 A6& a6; 00543 A7& a7; 00544 }; 00545 00546 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> 00547 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> { 00548 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> value_type; 00549 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8> tuple_type; 00550 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) : 00551 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} 00552 template <typename Packer> 00553 void msgpack_pack(Packer& pk) const 00554 { 00555 pk.pack_array(9); 00556 00557 pk.pack(a0); 00558 pk.pack(a1); 00559 pk.pack(a2); 00560 pk.pack(a3); 00561 pk.pack(a4); 00562 pk.pack(a5); 00563 pk.pack(a6); 00564 pk.pack(a7); 00565 pk.pack(a8); 00566 } 00567 void msgpack_unpack(msgpack::object const& o) 00568 { 00569 if(o.type != msgpack::type::ARRAY) { 00570 printf("throw msgpack::type_error()"); 00571 // throw msgpack::type_error(); 00572 } 00573 const size_t size = o.via.array.size; 00574 if(size > 0) { 00575 msgpack::object *ptr = o.via.array.ptr; 00576 switch(size) { 00577 default: 00578 case 9: ptr[8].convert(a8); 00579 case 8: ptr[7].convert(a7); 00580 case 7: ptr[6].convert(a6); 00581 case 6: ptr[5].convert(a5); 00582 case 5: ptr[4].convert(a4); 00583 case 4: ptr[3].convert(a3); 00584 case 3: ptr[2].convert(a2); 00585 case 2: ptr[1].convert(a1); 00586 case 1: ptr[0].convert(a0); 00587 } 00588 } 00589 } 00590 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00591 { 00592 o->type = msgpack::type::ARRAY; 00593 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*9)); 00594 o->via.array.size = 9; 00595 00596 o->via.array.ptr[0] = msgpack::object(a0, z); 00597 o->via.array.ptr[1] = msgpack::object(a1, z); 00598 o->via.array.ptr[2] = msgpack::object(a2, z); 00599 o->via.array.ptr[3] = msgpack::object(a3, z); 00600 o->via.array.ptr[4] = msgpack::object(a4, z); 00601 o->via.array.ptr[5] = msgpack::object(a5, z); 00602 o->via.array.ptr[6] = msgpack::object(a6, z); 00603 o->via.array.ptr[7] = msgpack::object(a7, z); 00604 o->via.array.ptr[8] = msgpack::object(a8, z); 00605 } 00606 00607 A0& a0; 00608 A1& a1; 00609 A2& a2; 00610 A3& a3; 00611 A4& a4; 00612 A5& a5; 00613 A6& a6; 00614 A7& a7; 00615 A8& a8; 00616 }; 00617 00618 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> 00619 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> { 00620 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> value_type; 00621 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> tuple_type; 00622 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) : 00623 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} 00624 template <typename Packer> 00625 void msgpack_pack(Packer& pk) const 00626 { 00627 pk.pack_array(10); 00628 00629 pk.pack(a0); 00630 pk.pack(a1); 00631 pk.pack(a2); 00632 pk.pack(a3); 00633 pk.pack(a4); 00634 pk.pack(a5); 00635 pk.pack(a6); 00636 pk.pack(a7); 00637 pk.pack(a8); 00638 pk.pack(a9); 00639 } 00640 void msgpack_unpack(msgpack::object const& o) 00641 { 00642 if(o.type != msgpack::type::ARRAY) { 00643 printf("throw msgpack::type_error()"); 00644 // throw msgpack::type_error(); 00645 } 00646 const size_t size = o.via.array.size; 00647 if(size > 0) { 00648 msgpack::object *ptr = o.via.array.ptr; 00649 switch(size) { 00650 default: 00651 case 10: ptr[9].convert(a9); 00652 case 9: ptr[8].convert(a8); 00653 case 8: ptr[7].convert(a7); 00654 case 7: ptr[6].convert(a6); 00655 case 6: ptr[5].convert(a5); 00656 case 5: ptr[4].convert(a4); 00657 case 4: ptr[3].convert(a3); 00658 case 3: ptr[2].convert(a2); 00659 case 2: ptr[1].convert(a1); 00660 case 1: ptr[0].convert(a0); 00661 } 00662 } 00663 } 00664 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00665 { 00666 o->type = msgpack::type::ARRAY; 00667 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*10)); 00668 o->via.array.size = 10; 00669 00670 o->via.array.ptr[0] = msgpack::object(a0, z); 00671 o->via.array.ptr[1] = msgpack::object(a1, z); 00672 o->via.array.ptr[2] = msgpack::object(a2, z); 00673 o->via.array.ptr[3] = msgpack::object(a3, z); 00674 o->via.array.ptr[4] = msgpack::object(a4, z); 00675 o->via.array.ptr[5] = msgpack::object(a5, z); 00676 o->via.array.ptr[6] = msgpack::object(a6, z); 00677 o->via.array.ptr[7] = msgpack::object(a7, z); 00678 o->via.array.ptr[8] = msgpack::object(a8, z); 00679 o->via.array.ptr[9] = msgpack::object(a9, z); 00680 } 00681 00682 A0& a0; 00683 A1& a1; 00684 A2& a2; 00685 A3& a3; 00686 A4& a4; 00687 A5& a5; 00688 A6& a6; 00689 A7& a7; 00690 A8& a8; 00691 A9& a9; 00692 }; 00693 00694 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> 00695 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> { 00696 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> value_type; 00697 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> tuple_type; 00698 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) : 00699 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} 00700 template <typename Packer> 00701 void msgpack_pack(Packer& pk) const 00702 { 00703 pk.pack_array(11); 00704 00705 pk.pack(a0); 00706 pk.pack(a1); 00707 pk.pack(a2); 00708 pk.pack(a3); 00709 pk.pack(a4); 00710 pk.pack(a5); 00711 pk.pack(a6); 00712 pk.pack(a7); 00713 pk.pack(a8); 00714 pk.pack(a9); 00715 pk.pack(a10); 00716 } 00717 void msgpack_unpack(msgpack::object const& o) 00718 { 00719 if(o.type != msgpack::type::ARRAY) { 00720 printf("throw msgpack::type_error()"); 00721 // throw msgpack::type_error(); 00722 } 00723 const size_t size = o.via.array.size; 00724 if(size > 0) { 00725 msgpack::object *ptr = o.via.array.ptr; 00726 switch(size) { 00727 default: 00728 case 11: ptr[10].convert(a10); 00729 case 10: ptr[9].convert(a9); 00730 case 9: ptr[8].convert(a8); 00731 case 8: ptr[7].convert(a7); 00732 case 7: ptr[6].convert(a6); 00733 case 6: ptr[5].convert(a5); 00734 case 5: ptr[4].convert(a4); 00735 case 4: ptr[3].convert(a3); 00736 case 3: ptr[2].convert(a2); 00737 case 2: ptr[1].convert(a1); 00738 case 1: ptr[0].convert(a0); 00739 } 00740 } 00741 } 00742 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00743 { 00744 o->type = msgpack::type::ARRAY; 00745 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*11)); 00746 o->via.array.size = 11; 00747 00748 o->via.array.ptr[0] = msgpack::object(a0, z); 00749 o->via.array.ptr[1] = msgpack::object(a1, z); 00750 o->via.array.ptr[2] = msgpack::object(a2, z); 00751 o->via.array.ptr[3] = msgpack::object(a3, z); 00752 o->via.array.ptr[4] = msgpack::object(a4, z); 00753 o->via.array.ptr[5] = msgpack::object(a5, z); 00754 o->via.array.ptr[6] = msgpack::object(a6, z); 00755 o->via.array.ptr[7] = msgpack::object(a7, z); 00756 o->via.array.ptr[8] = msgpack::object(a8, z); 00757 o->via.array.ptr[9] = msgpack::object(a9, z); 00758 o->via.array.ptr[10] = msgpack::object(a10, z); 00759 } 00760 00761 A0& a0; 00762 A1& a1; 00763 A2& a2; 00764 A3& a3; 00765 A4& a4; 00766 A5& a5; 00767 A6& a6; 00768 A7& a7; 00769 A8& a8; 00770 A9& a9; 00771 A10& a10; 00772 }; 00773 00774 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> 00775 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> { 00776 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> value_type; 00777 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> tuple_type; 00778 define_array(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : 00779 a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} 00780 template <typename Packer> 00781 void msgpack_pack(Packer& pk) const 00782 { 00783 pk.pack_array(12); 00784 00785 pk.pack(a0); 00786 pk.pack(a1); 00787 pk.pack(a2); 00788 pk.pack(a3); 00789 pk.pack(a4); 00790 pk.pack(a5); 00791 pk.pack(a6); 00792 pk.pack(a7); 00793 pk.pack(a8); 00794 pk.pack(a9); 00795 pk.pack(a10); 00796 pk.pack(a11); 00797 } 00798 void msgpack_unpack(msgpack::object const& o) 00799 { 00800 if(o.type != msgpack::type::ARRAY) { 00801 printf("throw msgpack::type_error()"); 00802 // throw msgpack::type_error(); 00803 } 00804 const size_t size = o.via.array.size; 00805 if(size > 0) { 00806 msgpack::object *ptr = o.via.array.ptr; 00807 switch(size) { 00808 default: 00809 case 12: ptr[11].convert(a11); 00810 case 11: ptr[10].convert(a10); 00811 case 10: ptr[9].convert(a9); 00812 case 9: ptr[8].convert(a8); 00813 case 8: ptr[7].convert(a7); 00814 case 7: ptr[6].convert(a6); 00815 case 6: ptr[5].convert(a5); 00816 case 5: ptr[4].convert(a4); 00817 case 4: ptr[3].convert(a3); 00818 case 3: ptr[2].convert(a2); 00819 case 2: ptr[1].convert(a1); 00820 case 1: ptr[0].convert(a0); 00821 } 00822 } 00823 } 00824 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00825 { 00826 o->type = msgpack::type::ARRAY; 00827 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*12)); 00828 o->via.array.size = 12; 00829 00830 o->via.array.ptr[0] = msgpack::object(a0, z); 00831 o->via.array.ptr[1] = msgpack::object(a1, z); 00832 o->via.array.ptr[2] = msgpack::object(a2, z); 00833 o->via.array.ptr[3] = msgpack::object(a3, z); 00834 o->via.array.ptr[4] = msgpack::object(a4, z); 00835 o->via.array.ptr[5] = msgpack::object(a5, z); 00836 o->via.array.ptr[6] = msgpack::object(a6, z); 00837 o->via.array.ptr[7] = msgpack::object(a7, z); 00838 o->via.array.ptr[8] = msgpack::object(a8, z); 00839 o->via.array.ptr[9] = msgpack::object(a9, z); 00840 o->via.array.ptr[10] = msgpack::object(a10, z); 00841 o->via.array.ptr[11] = msgpack::object(a11, z); 00842 } 00843 00844 A0& a0; 00845 A1& a1; 00846 A2& a2; 00847 A3& a3; 00848 A4& a4; 00849 A5& a5; 00850 A6& a6; 00851 A7& a7; 00852 A8& a8; 00853 A9& a9; 00854 A10& a10; 00855 A11& a11; 00856 }; 00857 00858 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> 00859 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> { 00860 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> value_type; 00861 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> tuple_type; 00862 define_array(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) : 00863 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) {} 00864 template <typename Packer> 00865 void msgpack_pack(Packer& pk) const 00866 { 00867 pk.pack_array(13); 00868 00869 pk.pack(a0); 00870 pk.pack(a1); 00871 pk.pack(a2); 00872 pk.pack(a3); 00873 pk.pack(a4); 00874 pk.pack(a5); 00875 pk.pack(a6); 00876 pk.pack(a7); 00877 pk.pack(a8); 00878 pk.pack(a9); 00879 pk.pack(a10); 00880 pk.pack(a11); 00881 pk.pack(a12); 00882 } 00883 void msgpack_unpack(msgpack::object const& o) 00884 { 00885 if(o.type != msgpack::type::ARRAY) { 00886 printf("throw msgpack::type_error()"); 00887 // throw msgpack::type_error(); 00888 } 00889 const size_t size = o.via.array.size; 00890 if(size > 0) { 00891 msgpack::object *ptr = o.via.array.ptr; 00892 switch(size) { 00893 default: 00894 case 13: ptr[12].convert(a12); 00895 case 12: ptr[11].convert(a11); 00896 case 11: ptr[10].convert(a10); 00897 case 10: ptr[9].convert(a9); 00898 case 9: ptr[8].convert(a8); 00899 case 8: ptr[7].convert(a7); 00900 case 7: ptr[6].convert(a6); 00901 case 6: ptr[5].convert(a5); 00902 case 5: ptr[4].convert(a4); 00903 case 4: ptr[3].convert(a3); 00904 case 3: ptr[2].convert(a2); 00905 case 2: ptr[1].convert(a1); 00906 case 1: ptr[0].convert(a0); 00907 } 00908 } 00909 } 00910 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 00911 { 00912 o->type = msgpack::type::ARRAY; 00913 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*13)); 00914 o->via.array.size = 13; 00915 00916 o->via.array.ptr[0] = msgpack::object(a0, z); 00917 o->via.array.ptr[1] = msgpack::object(a1, z); 00918 o->via.array.ptr[2] = msgpack::object(a2, z); 00919 o->via.array.ptr[3] = msgpack::object(a3, z); 00920 o->via.array.ptr[4] = msgpack::object(a4, z); 00921 o->via.array.ptr[5] = msgpack::object(a5, z); 00922 o->via.array.ptr[6] = msgpack::object(a6, z); 00923 o->via.array.ptr[7] = msgpack::object(a7, z); 00924 o->via.array.ptr[8] = msgpack::object(a8, z); 00925 o->via.array.ptr[9] = msgpack::object(a9, z); 00926 o->via.array.ptr[10] = msgpack::object(a10, z); 00927 o->via.array.ptr[11] = msgpack::object(a11, z); 00928 o->via.array.ptr[12] = msgpack::object(a12, z); 00929 } 00930 00931 A0& a0; 00932 A1& a1; 00933 A2& a2; 00934 A3& a3; 00935 A4& a4; 00936 A5& a5; 00937 A6& a6; 00938 A7& a7; 00939 A8& a8; 00940 A9& a9; 00941 A10& a10; 00942 A11& a11; 00943 A12& a12; 00944 }; 00945 00946 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> 00947 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> { 00948 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> value_type; 00949 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> tuple_type; 00950 define_array(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) : 00951 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) {} 00952 template <typename Packer> 00953 void msgpack_pack(Packer& pk) const 00954 { 00955 pk.pack_array(14); 00956 00957 pk.pack(a0); 00958 pk.pack(a1); 00959 pk.pack(a2); 00960 pk.pack(a3); 00961 pk.pack(a4); 00962 pk.pack(a5); 00963 pk.pack(a6); 00964 pk.pack(a7); 00965 pk.pack(a8); 00966 pk.pack(a9); 00967 pk.pack(a10); 00968 pk.pack(a11); 00969 pk.pack(a12); 00970 pk.pack(a13); 00971 } 00972 void msgpack_unpack(msgpack::object const& o) 00973 { 00974 if(o.type != msgpack::type::ARRAY) { 00975 printf("throw msgpack::type_error()"); 00976 // throw msgpack::type_error(); 00977 } 00978 const size_t size = o.via.array.size; 00979 if(size > 0) { 00980 msgpack::object *ptr = o.via.array.ptr; 00981 switch(size) { 00982 default: 00983 case 14: ptr[13].convert(a13); 00984 case 13: ptr[12].convert(a12); 00985 case 12: ptr[11].convert(a11); 00986 case 11: ptr[10].convert(a10); 00987 case 10: ptr[9].convert(a9); 00988 case 9: ptr[8].convert(a8); 00989 case 8: ptr[7].convert(a7); 00990 case 7: ptr[6].convert(a6); 00991 case 6: ptr[5].convert(a5); 00992 case 5: ptr[4].convert(a4); 00993 case 4: ptr[3].convert(a3); 00994 case 3: ptr[2].convert(a2); 00995 case 2: ptr[1].convert(a1); 00996 case 1: ptr[0].convert(a0); 00997 } 00998 } 00999 } 01000 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01001 { 01002 o->type = msgpack::type::ARRAY; 01003 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*14)); 01004 o->via.array.size = 14; 01005 01006 o->via.array.ptr[0] = msgpack::object(a0, z); 01007 o->via.array.ptr[1] = msgpack::object(a1, z); 01008 o->via.array.ptr[2] = msgpack::object(a2, z); 01009 o->via.array.ptr[3] = msgpack::object(a3, z); 01010 o->via.array.ptr[4] = msgpack::object(a4, z); 01011 o->via.array.ptr[5] = msgpack::object(a5, z); 01012 o->via.array.ptr[6] = msgpack::object(a6, z); 01013 o->via.array.ptr[7] = msgpack::object(a7, z); 01014 o->via.array.ptr[8] = msgpack::object(a8, z); 01015 o->via.array.ptr[9] = msgpack::object(a9, z); 01016 o->via.array.ptr[10] = msgpack::object(a10, z); 01017 o->via.array.ptr[11] = msgpack::object(a11, z); 01018 o->via.array.ptr[12] = msgpack::object(a12, z); 01019 o->via.array.ptr[13] = msgpack::object(a13, z); 01020 } 01021 01022 A0& a0; 01023 A1& a1; 01024 A2& a2; 01025 A3& a3; 01026 A4& a4; 01027 A5& a5; 01028 A6& a6; 01029 A7& a7; 01030 A8& a8; 01031 A9& a9; 01032 A10& a10; 01033 A11& a11; 01034 A12& a12; 01035 A13& a13; 01036 }; 01037 01038 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> 01039 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> { 01040 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> value_type; 01041 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> tuple_type; 01042 define_array(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) : 01043 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) {} 01044 template <typename Packer> 01045 void msgpack_pack(Packer& pk) const 01046 { 01047 pk.pack_array(15); 01048 01049 pk.pack(a0); 01050 pk.pack(a1); 01051 pk.pack(a2); 01052 pk.pack(a3); 01053 pk.pack(a4); 01054 pk.pack(a5); 01055 pk.pack(a6); 01056 pk.pack(a7); 01057 pk.pack(a8); 01058 pk.pack(a9); 01059 pk.pack(a10); 01060 pk.pack(a11); 01061 pk.pack(a12); 01062 pk.pack(a13); 01063 pk.pack(a14); 01064 } 01065 void msgpack_unpack(msgpack::object const& o) 01066 { 01067 if(o.type != msgpack::type::ARRAY) { 01068 printf("throw msgpack::type_error()"); 01069 throw msgpack::type_error(); 01070 } 01071 const size_t size = o.via.array.size; 01072 if(size > 0) { 01073 msgpack::object *ptr = o.via.array.ptr; 01074 switch(size) { 01075 default: 01076 case 15: ptr[14].convert(a14); 01077 case 14: ptr[13].convert(a13); 01078 case 13: ptr[12].convert(a12); 01079 case 12: ptr[11].convert(a11); 01080 case 11: ptr[10].convert(a10); 01081 case 10: ptr[9].convert(a9); 01082 case 9: ptr[8].convert(a8); 01083 case 8: ptr[7].convert(a7); 01084 case 7: ptr[6].convert(a6); 01085 case 6: ptr[5].convert(a5); 01086 case 5: ptr[4].convert(a4); 01087 case 4: ptr[3].convert(a3); 01088 case 3: ptr[2].convert(a2); 01089 case 2: ptr[1].convert(a1); 01090 case 1: ptr[0].convert(a0); 01091 } 01092 } 01093 } 01094 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01095 { 01096 o->type = msgpack::type::ARRAY; 01097 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*15)); 01098 o->via.array.size = 15; 01099 01100 o->via.array.ptr[0] = msgpack::object(a0, z); 01101 o->via.array.ptr[1] = msgpack::object(a1, z); 01102 o->via.array.ptr[2] = msgpack::object(a2, z); 01103 o->via.array.ptr[3] = msgpack::object(a3, z); 01104 o->via.array.ptr[4] = msgpack::object(a4, z); 01105 o->via.array.ptr[5] = msgpack::object(a5, z); 01106 o->via.array.ptr[6] = msgpack::object(a6, z); 01107 o->via.array.ptr[7] = msgpack::object(a7, z); 01108 o->via.array.ptr[8] = msgpack::object(a8, z); 01109 o->via.array.ptr[9] = msgpack::object(a9, z); 01110 o->via.array.ptr[10] = msgpack::object(a10, z); 01111 o->via.array.ptr[11] = msgpack::object(a11, z); 01112 o->via.array.ptr[12] = msgpack::object(a12, z); 01113 o->via.array.ptr[13] = msgpack::object(a13, z); 01114 o->via.array.ptr[14] = msgpack::object(a14, z); 01115 } 01116 01117 A0& a0; 01118 A1& a1; 01119 A2& a2; 01120 A3& a3; 01121 A4& a4; 01122 A5& a5; 01123 A6& a6; 01124 A7& a7; 01125 A8& a8; 01126 A9& a9; 01127 A10& a10; 01128 A11& a11; 01129 A12& a12; 01130 A13& a13; 01131 A14& a14; 01132 }; 01133 01134 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> 01135 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> { 01136 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> value_type; 01137 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> tuple_type; 01138 define_array(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) : 01139 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) {} 01140 template <typename Packer> 01141 void msgpack_pack(Packer& pk) const 01142 { 01143 pk.pack_array(16); 01144 01145 pk.pack(a0); 01146 pk.pack(a1); 01147 pk.pack(a2); 01148 pk.pack(a3); 01149 pk.pack(a4); 01150 pk.pack(a5); 01151 pk.pack(a6); 01152 pk.pack(a7); 01153 pk.pack(a8); 01154 pk.pack(a9); 01155 pk.pack(a10); 01156 pk.pack(a11); 01157 pk.pack(a12); 01158 pk.pack(a13); 01159 pk.pack(a14); 01160 pk.pack(a15); 01161 } 01162 void msgpack_unpack(msgpack::object const& o) 01163 { 01164 if(o.type != msgpack::type::ARRAY) { 01165 printf("throw msgpack::type_error()"); 01166 // throw msgpack::type_error(); 01167 } 01168 const size_t size = o.via.array.size; 01169 if(size > 0) { 01170 msgpack::object *ptr = o.via.array.ptr; 01171 switch(size) { 01172 default: 01173 case 16: ptr[15].convert(a15); 01174 case 15: ptr[14].convert(a14); 01175 case 14: ptr[13].convert(a13); 01176 case 13: ptr[12].convert(a12); 01177 case 12: ptr[11].convert(a11); 01178 case 11: ptr[10].convert(a10); 01179 case 10: ptr[9].convert(a9); 01180 case 9: ptr[8].convert(a8); 01181 case 8: ptr[7].convert(a7); 01182 case 7: ptr[6].convert(a6); 01183 case 6: ptr[5].convert(a5); 01184 case 5: ptr[4].convert(a4); 01185 case 4: ptr[3].convert(a3); 01186 case 3: ptr[2].convert(a2); 01187 case 2: ptr[1].convert(a1); 01188 case 1: ptr[0].convert(a0); 01189 } 01190 } 01191 } 01192 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01193 { 01194 o->type = msgpack::type::ARRAY; 01195 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*16)); 01196 o->via.array.size = 16; 01197 01198 o->via.array.ptr[0] = msgpack::object(a0, z); 01199 o->via.array.ptr[1] = msgpack::object(a1, z); 01200 o->via.array.ptr[2] = msgpack::object(a2, z); 01201 o->via.array.ptr[3] = msgpack::object(a3, z); 01202 o->via.array.ptr[4] = msgpack::object(a4, z); 01203 o->via.array.ptr[5] = msgpack::object(a5, z); 01204 o->via.array.ptr[6] = msgpack::object(a6, z); 01205 o->via.array.ptr[7] = msgpack::object(a7, z); 01206 o->via.array.ptr[8] = msgpack::object(a8, z); 01207 o->via.array.ptr[9] = msgpack::object(a9, z); 01208 o->via.array.ptr[10] = msgpack::object(a10, z); 01209 o->via.array.ptr[11] = msgpack::object(a11, z); 01210 o->via.array.ptr[12] = msgpack::object(a12, z); 01211 o->via.array.ptr[13] = msgpack::object(a13, z); 01212 o->via.array.ptr[14] = msgpack::object(a14, z); 01213 o->via.array.ptr[15] = msgpack::object(a15, z); 01214 } 01215 01216 A0& a0; 01217 A1& a1; 01218 A2& a2; 01219 A3& a3; 01220 A4& a4; 01221 A5& a5; 01222 A6& a6; 01223 A7& a7; 01224 A8& a8; 01225 A9& a9; 01226 A10& a10; 01227 A11& a11; 01228 A12& a12; 01229 A13& a13; 01230 A14& a14; 01231 A15& a15; 01232 }; 01233 01234 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> 01235 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> { 01236 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> value_type; 01237 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> tuple_type; 01238 define_array(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) : 01239 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) {} 01240 template <typename Packer> 01241 void msgpack_pack(Packer& pk) const 01242 { 01243 pk.pack_array(17); 01244 01245 pk.pack(a0); 01246 pk.pack(a1); 01247 pk.pack(a2); 01248 pk.pack(a3); 01249 pk.pack(a4); 01250 pk.pack(a5); 01251 pk.pack(a6); 01252 pk.pack(a7); 01253 pk.pack(a8); 01254 pk.pack(a9); 01255 pk.pack(a10); 01256 pk.pack(a11); 01257 pk.pack(a12); 01258 pk.pack(a13); 01259 pk.pack(a14); 01260 pk.pack(a15); 01261 pk.pack(a16); 01262 } 01263 void msgpack_unpack(msgpack::object const& o) 01264 { 01265 if(o.type != msgpack::type::ARRAY) { 01266 printf("throw msgpack::type_error()"); 01267 // throw msgpack::type_error(); 01268 } 01269 const size_t size = o.via.array.size; 01270 if(size > 0) { 01271 msgpack::object *ptr = o.via.array.ptr; 01272 switch(size) { 01273 default: 01274 case 17: ptr[16].convert(a16); 01275 case 16: ptr[15].convert(a15); 01276 case 15: ptr[14].convert(a14); 01277 case 14: ptr[13].convert(a13); 01278 case 13: ptr[12].convert(a12); 01279 case 12: ptr[11].convert(a11); 01280 case 11: ptr[10].convert(a10); 01281 case 10: ptr[9].convert(a9); 01282 case 9: ptr[8].convert(a8); 01283 case 8: ptr[7].convert(a7); 01284 case 7: ptr[6].convert(a6); 01285 case 6: ptr[5].convert(a5); 01286 case 5: ptr[4].convert(a4); 01287 case 4: ptr[3].convert(a3); 01288 case 3: ptr[2].convert(a2); 01289 case 2: ptr[1].convert(a1); 01290 case 1: ptr[0].convert(a0); 01291 } 01292 } 01293 } 01294 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01295 { 01296 o->type = msgpack::type::ARRAY; 01297 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*17)); 01298 o->via.array.size = 17; 01299 01300 o->via.array.ptr[0] = msgpack::object(a0, z); 01301 o->via.array.ptr[1] = msgpack::object(a1, z); 01302 o->via.array.ptr[2] = msgpack::object(a2, z); 01303 o->via.array.ptr[3] = msgpack::object(a3, z); 01304 o->via.array.ptr[4] = msgpack::object(a4, z); 01305 o->via.array.ptr[5] = msgpack::object(a5, z); 01306 o->via.array.ptr[6] = msgpack::object(a6, z); 01307 o->via.array.ptr[7] = msgpack::object(a7, z); 01308 o->via.array.ptr[8] = msgpack::object(a8, z); 01309 o->via.array.ptr[9] = msgpack::object(a9, z); 01310 o->via.array.ptr[10] = msgpack::object(a10, z); 01311 o->via.array.ptr[11] = msgpack::object(a11, z); 01312 o->via.array.ptr[12] = msgpack::object(a12, z); 01313 o->via.array.ptr[13] = msgpack::object(a13, z); 01314 o->via.array.ptr[14] = msgpack::object(a14, z); 01315 o->via.array.ptr[15] = msgpack::object(a15, z); 01316 o->via.array.ptr[16] = msgpack::object(a16, z); 01317 } 01318 01319 A0& a0; 01320 A1& a1; 01321 A2& a2; 01322 A3& a3; 01323 A4& a4; 01324 A5& a5; 01325 A6& a6; 01326 A7& a7; 01327 A8& a8; 01328 A9& a9; 01329 A10& a10; 01330 A11& a11; 01331 A12& a12; 01332 A13& a13; 01333 A14& a14; 01334 A15& a15; 01335 A16& a16; 01336 }; 01337 01338 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> 01339 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> { 01340 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> value_type; 01341 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> tuple_type; 01342 define_array(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) : 01343 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) {} 01344 template <typename Packer> 01345 void msgpack_pack(Packer& pk) const 01346 { 01347 pk.pack_array(18); 01348 01349 pk.pack(a0); 01350 pk.pack(a1); 01351 pk.pack(a2); 01352 pk.pack(a3); 01353 pk.pack(a4); 01354 pk.pack(a5); 01355 pk.pack(a6); 01356 pk.pack(a7); 01357 pk.pack(a8); 01358 pk.pack(a9); 01359 pk.pack(a10); 01360 pk.pack(a11); 01361 pk.pack(a12); 01362 pk.pack(a13); 01363 pk.pack(a14); 01364 pk.pack(a15); 01365 pk.pack(a16); 01366 pk.pack(a17); 01367 } 01368 void msgpack_unpack(msgpack::object const& o) 01369 { 01370 if(o.type != msgpack::type::ARRAY) { 01371 printf("throw msgpack::type_error()"); 01372 // throw msgpack::type_error(); 01373 } 01374 const size_t size = o.via.array.size; 01375 if(size > 0) { 01376 msgpack::object *ptr = o.via.array.ptr; 01377 switch(size) { 01378 default: 01379 case 18: ptr[17].convert(a17); 01380 case 17: ptr[16].convert(a16); 01381 case 16: ptr[15].convert(a15); 01382 case 15: ptr[14].convert(a14); 01383 case 14: ptr[13].convert(a13); 01384 case 13: ptr[12].convert(a12); 01385 case 12: ptr[11].convert(a11); 01386 case 11: ptr[10].convert(a10); 01387 case 10: ptr[9].convert(a9); 01388 case 9: ptr[8].convert(a8); 01389 case 8: ptr[7].convert(a7); 01390 case 7: ptr[6].convert(a6); 01391 case 6: ptr[5].convert(a5); 01392 case 5: ptr[4].convert(a4); 01393 case 4: ptr[3].convert(a3); 01394 case 3: ptr[2].convert(a2); 01395 case 2: ptr[1].convert(a1); 01396 case 1: ptr[0].convert(a0); 01397 } 01398 } 01399 } 01400 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01401 { 01402 o->type = msgpack::type::ARRAY; 01403 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*18)); 01404 o->via.array.size = 18; 01405 01406 o->via.array.ptr[0] = msgpack::object(a0, z); 01407 o->via.array.ptr[1] = msgpack::object(a1, z); 01408 o->via.array.ptr[2] = msgpack::object(a2, z); 01409 o->via.array.ptr[3] = msgpack::object(a3, z); 01410 o->via.array.ptr[4] = msgpack::object(a4, z); 01411 o->via.array.ptr[5] = msgpack::object(a5, z); 01412 o->via.array.ptr[6] = msgpack::object(a6, z); 01413 o->via.array.ptr[7] = msgpack::object(a7, z); 01414 o->via.array.ptr[8] = msgpack::object(a8, z); 01415 o->via.array.ptr[9] = msgpack::object(a9, z); 01416 o->via.array.ptr[10] = msgpack::object(a10, z); 01417 o->via.array.ptr[11] = msgpack::object(a11, z); 01418 o->via.array.ptr[12] = msgpack::object(a12, z); 01419 o->via.array.ptr[13] = msgpack::object(a13, z); 01420 o->via.array.ptr[14] = msgpack::object(a14, z); 01421 o->via.array.ptr[15] = msgpack::object(a15, z); 01422 o->via.array.ptr[16] = msgpack::object(a16, z); 01423 o->via.array.ptr[17] = msgpack::object(a17, z); 01424 } 01425 01426 A0& a0; 01427 A1& a1; 01428 A2& a2; 01429 A3& a3; 01430 A4& a4; 01431 A5& a5; 01432 A6& a6; 01433 A7& a7; 01434 A8& a8; 01435 A9& a9; 01436 A10& a10; 01437 A11& a11; 01438 A12& a12; 01439 A13& a13; 01440 A14& a14; 01441 A15& a15; 01442 A16& a16; 01443 A17& a17; 01444 }; 01445 01446 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> 01447 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> { 01448 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> value_type; 01449 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> tuple_type; 01450 define_array(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) : 01451 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) {} 01452 template <typename Packer> 01453 void msgpack_pack(Packer& pk) const 01454 { 01455 pk.pack_array(19); 01456 01457 pk.pack(a0); 01458 pk.pack(a1); 01459 pk.pack(a2); 01460 pk.pack(a3); 01461 pk.pack(a4); 01462 pk.pack(a5); 01463 pk.pack(a6); 01464 pk.pack(a7); 01465 pk.pack(a8); 01466 pk.pack(a9); 01467 pk.pack(a10); 01468 pk.pack(a11); 01469 pk.pack(a12); 01470 pk.pack(a13); 01471 pk.pack(a14); 01472 pk.pack(a15); 01473 pk.pack(a16); 01474 pk.pack(a17); 01475 pk.pack(a18); 01476 } 01477 void msgpack_unpack(msgpack::object const& o) 01478 { 01479 if(o.type != msgpack::type::ARRAY) { 01480 printf("throw msgpack::type_error()"); 01481 // throw msgpack::type_error(); 01482 } 01483 const size_t size = o.via.array.size; 01484 if(size > 0) { 01485 msgpack::object *ptr = o.via.array.ptr; 01486 switch(size) { 01487 default: 01488 case 19: ptr[18].convert(a18); 01489 case 18: ptr[17].convert(a17); 01490 case 17: ptr[16].convert(a16); 01491 case 16: ptr[15].convert(a15); 01492 case 15: ptr[14].convert(a14); 01493 case 14: ptr[13].convert(a13); 01494 case 13: ptr[12].convert(a12); 01495 case 12: ptr[11].convert(a11); 01496 case 11: ptr[10].convert(a10); 01497 case 10: ptr[9].convert(a9); 01498 case 9: ptr[8].convert(a8); 01499 case 8: ptr[7].convert(a7); 01500 case 7: ptr[6].convert(a6); 01501 case 6: ptr[5].convert(a5); 01502 case 5: ptr[4].convert(a4); 01503 case 4: ptr[3].convert(a3); 01504 case 3: ptr[2].convert(a2); 01505 case 2: ptr[1].convert(a1); 01506 case 1: ptr[0].convert(a0); 01507 } 01508 } 01509 } 01510 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01511 { 01512 o->type = msgpack::type::ARRAY; 01513 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*19)); 01514 o->via.array.size = 19; 01515 01516 o->via.array.ptr[0] = msgpack::object(a0, z); 01517 o->via.array.ptr[1] = msgpack::object(a1, z); 01518 o->via.array.ptr[2] = msgpack::object(a2, z); 01519 o->via.array.ptr[3] = msgpack::object(a3, z); 01520 o->via.array.ptr[4] = msgpack::object(a4, z); 01521 o->via.array.ptr[5] = msgpack::object(a5, z); 01522 o->via.array.ptr[6] = msgpack::object(a6, z); 01523 o->via.array.ptr[7] = msgpack::object(a7, z); 01524 o->via.array.ptr[8] = msgpack::object(a8, z); 01525 o->via.array.ptr[9] = msgpack::object(a9, z); 01526 o->via.array.ptr[10] = msgpack::object(a10, z); 01527 o->via.array.ptr[11] = msgpack::object(a11, z); 01528 o->via.array.ptr[12] = msgpack::object(a12, z); 01529 o->via.array.ptr[13] = msgpack::object(a13, z); 01530 o->via.array.ptr[14] = msgpack::object(a14, z); 01531 o->via.array.ptr[15] = msgpack::object(a15, z); 01532 o->via.array.ptr[16] = msgpack::object(a16, z); 01533 o->via.array.ptr[17] = msgpack::object(a17, z); 01534 o->via.array.ptr[18] = msgpack::object(a18, z); 01535 } 01536 01537 A0& a0; 01538 A1& a1; 01539 A2& a2; 01540 A3& a3; 01541 A4& a4; 01542 A5& a5; 01543 A6& a6; 01544 A7& a7; 01545 A8& a8; 01546 A9& a9; 01547 A10& a10; 01548 A11& a11; 01549 A12& a12; 01550 A13& a13; 01551 A14& a14; 01552 A15& a15; 01553 A16& a16; 01554 A17& a17; 01555 A18& a18; 01556 }; 01557 01558 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> 01559 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> { 01560 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> value_type; 01561 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> tuple_type; 01562 define_array(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) : 01563 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) {} 01564 template <typename Packer> 01565 void msgpack_pack(Packer& pk) const 01566 { 01567 pk.pack_array(20); 01568 01569 pk.pack(a0); 01570 pk.pack(a1); 01571 pk.pack(a2); 01572 pk.pack(a3); 01573 pk.pack(a4); 01574 pk.pack(a5); 01575 pk.pack(a6); 01576 pk.pack(a7); 01577 pk.pack(a8); 01578 pk.pack(a9); 01579 pk.pack(a10); 01580 pk.pack(a11); 01581 pk.pack(a12); 01582 pk.pack(a13); 01583 pk.pack(a14); 01584 pk.pack(a15); 01585 pk.pack(a16); 01586 pk.pack(a17); 01587 pk.pack(a18); 01588 pk.pack(a19); 01589 } 01590 void msgpack_unpack(msgpack::object const& o) 01591 { 01592 if(o.type != msgpack::type::ARRAY) { 01593 printf("throw msgpack::type_error()"); 01594 // throw msgpack::type_error(); 01595 } 01596 const size_t size = o.via.array.size; 01597 if(size > 0) { 01598 msgpack::object *ptr = o.via.array.ptr; 01599 switch(size) { 01600 default: 01601 case 20: ptr[19].convert(a19); 01602 case 19: ptr[18].convert(a18); 01603 case 18: ptr[17].convert(a17); 01604 case 17: ptr[16].convert(a16); 01605 case 16: ptr[15].convert(a15); 01606 case 15: ptr[14].convert(a14); 01607 case 14: ptr[13].convert(a13); 01608 case 13: ptr[12].convert(a12); 01609 case 12: ptr[11].convert(a11); 01610 case 11: ptr[10].convert(a10); 01611 case 10: ptr[9].convert(a9); 01612 case 9: ptr[8].convert(a8); 01613 case 8: ptr[7].convert(a7); 01614 case 7: ptr[6].convert(a6); 01615 case 6: ptr[5].convert(a5); 01616 case 5: ptr[4].convert(a4); 01617 case 4: ptr[3].convert(a3); 01618 case 3: ptr[2].convert(a2); 01619 case 2: ptr[1].convert(a1); 01620 case 1: ptr[0].convert(a0); 01621 } 01622 } 01623 } 01624 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01625 { 01626 o->type = msgpack::type::ARRAY; 01627 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*20)); 01628 o->via.array.size = 20; 01629 01630 o->via.array.ptr[0] = msgpack::object(a0, z); 01631 o->via.array.ptr[1] = msgpack::object(a1, z); 01632 o->via.array.ptr[2] = msgpack::object(a2, z); 01633 o->via.array.ptr[3] = msgpack::object(a3, z); 01634 o->via.array.ptr[4] = msgpack::object(a4, z); 01635 o->via.array.ptr[5] = msgpack::object(a5, z); 01636 o->via.array.ptr[6] = msgpack::object(a6, z); 01637 o->via.array.ptr[7] = msgpack::object(a7, z); 01638 o->via.array.ptr[8] = msgpack::object(a8, z); 01639 o->via.array.ptr[9] = msgpack::object(a9, z); 01640 o->via.array.ptr[10] = msgpack::object(a10, z); 01641 o->via.array.ptr[11] = msgpack::object(a11, z); 01642 o->via.array.ptr[12] = msgpack::object(a12, z); 01643 o->via.array.ptr[13] = msgpack::object(a13, z); 01644 o->via.array.ptr[14] = msgpack::object(a14, z); 01645 o->via.array.ptr[15] = msgpack::object(a15, z); 01646 o->via.array.ptr[16] = msgpack::object(a16, z); 01647 o->via.array.ptr[17] = msgpack::object(a17, z); 01648 o->via.array.ptr[18] = msgpack::object(a18, z); 01649 o->via.array.ptr[19] = msgpack::object(a19, z); 01650 } 01651 01652 A0& a0; 01653 A1& a1; 01654 A2& a2; 01655 A3& a3; 01656 A4& a4; 01657 A5& a5; 01658 A6& a6; 01659 A7& a7; 01660 A8& a8; 01661 A9& a9; 01662 A10& a10; 01663 A11& a11; 01664 A12& a12; 01665 A13& a13; 01666 A14& a14; 01667 A15& a15; 01668 A16& a16; 01669 A17& a17; 01670 A18& a18; 01671 A19& a19; 01672 }; 01673 01674 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> 01675 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> { 01676 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> value_type; 01677 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> tuple_type; 01678 define_array(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) : 01679 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) {} 01680 template <typename Packer> 01681 void msgpack_pack(Packer& pk) const 01682 { 01683 pk.pack_array(21); 01684 01685 pk.pack(a0); 01686 pk.pack(a1); 01687 pk.pack(a2); 01688 pk.pack(a3); 01689 pk.pack(a4); 01690 pk.pack(a5); 01691 pk.pack(a6); 01692 pk.pack(a7); 01693 pk.pack(a8); 01694 pk.pack(a9); 01695 pk.pack(a10); 01696 pk.pack(a11); 01697 pk.pack(a12); 01698 pk.pack(a13); 01699 pk.pack(a14); 01700 pk.pack(a15); 01701 pk.pack(a16); 01702 pk.pack(a17); 01703 pk.pack(a18); 01704 pk.pack(a19); 01705 pk.pack(a20); 01706 } 01707 void msgpack_unpack(msgpack::object const& o) 01708 { 01709 if(o.type != msgpack::type::ARRAY) { 01710 printf("throw msgpack::type_error()"); 01711 // throw msgpack::type_error(); 01712 } 01713 const size_t size = o.via.array.size; 01714 if(size > 0) { 01715 msgpack::object *ptr = o.via.array.ptr; 01716 switch(size) { 01717 default: 01718 case 21: ptr[20].convert(a20); 01719 case 20: ptr[19].convert(a19); 01720 case 19: ptr[18].convert(a18); 01721 case 18: ptr[17].convert(a17); 01722 case 17: ptr[16].convert(a16); 01723 case 16: ptr[15].convert(a15); 01724 case 15: ptr[14].convert(a14); 01725 case 14: ptr[13].convert(a13); 01726 case 13: ptr[12].convert(a12); 01727 case 12: ptr[11].convert(a11); 01728 case 11: ptr[10].convert(a10); 01729 case 10: ptr[9].convert(a9); 01730 case 9: ptr[8].convert(a8); 01731 case 8: ptr[7].convert(a7); 01732 case 7: ptr[6].convert(a6); 01733 case 6: ptr[5].convert(a5); 01734 case 5: ptr[4].convert(a4); 01735 case 4: ptr[3].convert(a3); 01736 case 3: ptr[2].convert(a2); 01737 case 2: ptr[1].convert(a1); 01738 case 1: ptr[0].convert(a0); 01739 } 01740 } 01741 } 01742 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01743 { 01744 o->type = msgpack::type::ARRAY; 01745 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*21)); 01746 o->via.array.size = 21; 01747 01748 o->via.array.ptr[0] = msgpack::object(a0, z); 01749 o->via.array.ptr[1] = msgpack::object(a1, z); 01750 o->via.array.ptr[2] = msgpack::object(a2, z); 01751 o->via.array.ptr[3] = msgpack::object(a3, z); 01752 o->via.array.ptr[4] = msgpack::object(a4, z); 01753 o->via.array.ptr[5] = msgpack::object(a5, z); 01754 o->via.array.ptr[6] = msgpack::object(a6, z); 01755 o->via.array.ptr[7] = msgpack::object(a7, z); 01756 o->via.array.ptr[8] = msgpack::object(a8, z); 01757 o->via.array.ptr[9] = msgpack::object(a9, z); 01758 o->via.array.ptr[10] = msgpack::object(a10, z); 01759 o->via.array.ptr[11] = msgpack::object(a11, z); 01760 o->via.array.ptr[12] = msgpack::object(a12, z); 01761 o->via.array.ptr[13] = msgpack::object(a13, z); 01762 o->via.array.ptr[14] = msgpack::object(a14, z); 01763 o->via.array.ptr[15] = msgpack::object(a15, z); 01764 o->via.array.ptr[16] = msgpack::object(a16, z); 01765 o->via.array.ptr[17] = msgpack::object(a17, z); 01766 o->via.array.ptr[18] = msgpack::object(a18, z); 01767 o->via.array.ptr[19] = msgpack::object(a19, z); 01768 o->via.array.ptr[20] = msgpack::object(a20, z); 01769 } 01770 01771 A0& a0; 01772 A1& a1; 01773 A2& a2; 01774 A3& a3; 01775 A4& a4; 01776 A5& a5; 01777 A6& a6; 01778 A7& a7; 01779 A8& a8; 01780 A9& a9; 01781 A10& a10; 01782 A11& a11; 01783 A12& a12; 01784 A13& a13; 01785 A14& a14; 01786 A15& a15; 01787 A16& a16; 01788 A17& a17; 01789 A18& a18; 01790 A19& a19; 01791 A20& a20; 01792 }; 01793 01794 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> 01795 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> { 01796 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> value_type; 01797 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> tuple_type; 01798 define_array(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) : 01799 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) {} 01800 template <typename Packer> 01801 void msgpack_pack(Packer& pk) const 01802 { 01803 pk.pack_array(22); 01804 01805 pk.pack(a0); 01806 pk.pack(a1); 01807 pk.pack(a2); 01808 pk.pack(a3); 01809 pk.pack(a4); 01810 pk.pack(a5); 01811 pk.pack(a6); 01812 pk.pack(a7); 01813 pk.pack(a8); 01814 pk.pack(a9); 01815 pk.pack(a10); 01816 pk.pack(a11); 01817 pk.pack(a12); 01818 pk.pack(a13); 01819 pk.pack(a14); 01820 pk.pack(a15); 01821 pk.pack(a16); 01822 pk.pack(a17); 01823 pk.pack(a18); 01824 pk.pack(a19); 01825 pk.pack(a20); 01826 pk.pack(a21); 01827 } 01828 void msgpack_unpack(msgpack::object const& o) 01829 { 01830 if(o.type != msgpack::type::ARRAY) { 01831 printf("throw msgpack::type_error()"); 01832 // throw msgpack::type_error(); 01833 } 01834 const size_t size = o.via.array.size; 01835 if(size > 0) { 01836 msgpack::object *ptr = o.via.array.ptr; 01837 switch(size) { 01838 default: 01839 case 22: ptr[21].convert(a21); 01840 case 21: ptr[20].convert(a20); 01841 case 20: ptr[19].convert(a19); 01842 case 19: ptr[18].convert(a18); 01843 case 18: ptr[17].convert(a17); 01844 case 17: ptr[16].convert(a16); 01845 case 16: ptr[15].convert(a15); 01846 case 15: ptr[14].convert(a14); 01847 case 14: ptr[13].convert(a13); 01848 case 13: ptr[12].convert(a12); 01849 case 12: ptr[11].convert(a11); 01850 case 11: ptr[10].convert(a10); 01851 case 10: ptr[9].convert(a9); 01852 case 9: ptr[8].convert(a8); 01853 case 8: ptr[7].convert(a7); 01854 case 7: ptr[6].convert(a6); 01855 case 6: ptr[5].convert(a5); 01856 case 5: ptr[4].convert(a4); 01857 case 4: ptr[3].convert(a3); 01858 case 3: ptr[2].convert(a2); 01859 case 2: ptr[1].convert(a1); 01860 case 1: ptr[0].convert(a0); 01861 } 01862 } 01863 } 01864 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01865 { 01866 o->type = msgpack::type::ARRAY; 01867 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*22)); 01868 o->via.array.size = 22; 01869 01870 o->via.array.ptr[0] = msgpack::object(a0, z); 01871 o->via.array.ptr[1] = msgpack::object(a1, z); 01872 o->via.array.ptr[2] = msgpack::object(a2, z); 01873 o->via.array.ptr[3] = msgpack::object(a3, z); 01874 o->via.array.ptr[4] = msgpack::object(a4, z); 01875 o->via.array.ptr[5] = msgpack::object(a5, z); 01876 o->via.array.ptr[6] = msgpack::object(a6, z); 01877 o->via.array.ptr[7] = msgpack::object(a7, z); 01878 o->via.array.ptr[8] = msgpack::object(a8, z); 01879 o->via.array.ptr[9] = msgpack::object(a9, z); 01880 o->via.array.ptr[10] = msgpack::object(a10, z); 01881 o->via.array.ptr[11] = msgpack::object(a11, z); 01882 o->via.array.ptr[12] = msgpack::object(a12, z); 01883 o->via.array.ptr[13] = msgpack::object(a13, z); 01884 o->via.array.ptr[14] = msgpack::object(a14, z); 01885 o->via.array.ptr[15] = msgpack::object(a15, z); 01886 o->via.array.ptr[16] = msgpack::object(a16, z); 01887 o->via.array.ptr[17] = msgpack::object(a17, z); 01888 o->via.array.ptr[18] = msgpack::object(a18, z); 01889 o->via.array.ptr[19] = msgpack::object(a19, z); 01890 o->via.array.ptr[20] = msgpack::object(a20, z); 01891 o->via.array.ptr[21] = msgpack::object(a21, z); 01892 } 01893 01894 A0& a0; 01895 A1& a1; 01896 A2& a2; 01897 A3& a3; 01898 A4& a4; 01899 A5& a5; 01900 A6& a6; 01901 A7& a7; 01902 A8& a8; 01903 A9& a9; 01904 A10& a10; 01905 A11& a11; 01906 A12& a12; 01907 A13& a13; 01908 A14& a14; 01909 A15& a15; 01910 A16& a16; 01911 A17& a17; 01912 A18& a18; 01913 A19& a19; 01914 A20& a20; 01915 A21& a21; 01916 }; 01917 01918 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> 01919 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> { 01920 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> value_type; 01921 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22> tuple_type; 01922 define_array(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) : 01923 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) {} 01924 template <typename Packer> 01925 void msgpack_pack(Packer& pk) const 01926 { 01927 pk.pack_array(23); 01928 01929 pk.pack(a0); 01930 pk.pack(a1); 01931 pk.pack(a2); 01932 pk.pack(a3); 01933 pk.pack(a4); 01934 pk.pack(a5); 01935 pk.pack(a6); 01936 pk.pack(a7); 01937 pk.pack(a8); 01938 pk.pack(a9); 01939 pk.pack(a10); 01940 pk.pack(a11); 01941 pk.pack(a12); 01942 pk.pack(a13); 01943 pk.pack(a14); 01944 pk.pack(a15); 01945 pk.pack(a16); 01946 pk.pack(a17); 01947 pk.pack(a18); 01948 pk.pack(a19); 01949 pk.pack(a20); 01950 pk.pack(a21); 01951 pk.pack(a22); 01952 } 01953 void msgpack_unpack(msgpack::object const& o) 01954 { 01955 if(o.type != msgpack::type::ARRAY) { 01956 printf("throw msgpack::type_error()"); 01957 // throw msgpack::type_error(); 01958 } 01959 const size_t size = o.via.array.size; 01960 if(size > 0) { 01961 msgpack::object *ptr = o.via.array.ptr; 01962 switch(size) { 01963 default: 01964 case 23: ptr[22].convert(a22); 01965 case 22: ptr[21].convert(a21); 01966 case 21: ptr[20].convert(a20); 01967 case 20: ptr[19].convert(a19); 01968 case 19: ptr[18].convert(a18); 01969 case 18: ptr[17].convert(a17); 01970 case 17: ptr[16].convert(a16); 01971 case 16: ptr[15].convert(a15); 01972 case 15: ptr[14].convert(a14); 01973 case 14: ptr[13].convert(a13); 01974 case 13: ptr[12].convert(a12); 01975 case 12: ptr[11].convert(a11); 01976 case 11: ptr[10].convert(a10); 01977 case 10: ptr[9].convert(a9); 01978 case 9: ptr[8].convert(a8); 01979 case 8: ptr[7].convert(a7); 01980 case 7: ptr[6].convert(a6); 01981 case 6: ptr[5].convert(a5); 01982 case 5: ptr[4].convert(a4); 01983 case 4: ptr[3].convert(a3); 01984 case 3: ptr[2].convert(a2); 01985 case 2: ptr[1].convert(a1); 01986 case 1: ptr[0].convert(a0); 01987 } 01988 } 01989 } 01990 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 01991 { 01992 o->type = msgpack::type::ARRAY; 01993 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*23)); 01994 o->via.array.size = 23; 01995 01996 o->via.array.ptr[0] = msgpack::object(a0, z); 01997 o->via.array.ptr[1] = msgpack::object(a1, z); 01998 o->via.array.ptr[2] = msgpack::object(a2, z); 01999 o->via.array.ptr[3] = msgpack::object(a3, z); 02000 o->via.array.ptr[4] = msgpack::object(a4, z); 02001 o->via.array.ptr[5] = msgpack::object(a5, z); 02002 o->via.array.ptr[6] = msgpack::object(a6, z); 02003 o->via.array.ptr[7] = msgpack::object(a7, z); 02004 o->via.array.ptr[8] = msgpack::object(a8, z); 02005 o->via.array.ptr[9] = msgpack::object(a9, z); 02006 o->via.array.ptr[10] = msgpack::object(a10, z); 02007 o->via.array.ptr[11] = msgpack::object(a11, z); 02008 o->via.array.ptr[12] = msgpack::object(a12, z); 02009 o->via.array.ptr[13] = msgpack::object(a13, z); 02010 o->via.array.ptr[14] = msgpack::object(a14, z); 02011 o->via.array.ptr[15] = msgpack::object(a15, z); 02012 o->via.array.ptr[16] = msgpack::object(a16, z); 02013 o->via.array.ptr[17] = msgpack::object(a17, z); 02014 o->via.array.ptr[18] = msgpack::object(a18, z); 02015 o->via.array.ptr[19] = msgpack::object(a19, z); 02016 o->via.array.ptr[20] = msgpack::object(a20, z); 02017 o->via.array.ptr[21] = msgpack::object(a21, z); 02018 o->via.array.ptr[22] = msgpack::object(a22, z); 02019 } 02020 02021 A0& a0; 02022 A1& a1; 02023 A2& a2; 02024 A3& a3; 02025 A4& a4; 02026 A5& a5; 02027 A6& a6; 02028 A7& a7; 02029 A8& a8; 02030 A9& a9; 02031 A10& a10; 02032 A11& a11; 02033 A12& a12; 02034 A13& a13; 02035 A14& a14; 02036 A15& a15; 02037 A16& a16; 02038 A17& a17; 02039 A18& a18; 02040 A19& a19; 02041 A20& a20; 02042 A21& a21; 02043 A22& a22; 02044 }; 02045 02046 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> 02047 struct define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> { 02048 typedef define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> value_type; 02049 typedef tuple<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23> tuple_type; 02050 define_array(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) : 02051 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) {} 02052 template <typename Packer> 02053 void msgpack_pack(Packer& pk) const 02054 { 02055 pk.pack_array(24); 02056 02057 pk.pack(a0); 02058 pk.pack(a1); 02059 pk.pack(a2); 02060 pk.pack(a3); 02061 pk.pack(a4); 02062 pk.pack(a5); 02063 pk.pack(a6); 02064 pk.pack(a7); 02065 pk.pack(a8); 02066 pk.pack(a9); 02067 pk.pack(a10); 02068 pk.pack(a11); 02069 pk.pack(a12); 02070 pk.pack(a13); 02071 pk.pack(a14); 02072 pk.pack(a15); 02073 pk.pack(a16); 02074 pk.pack(a17); 02075 pk.pack(a18); 02076 pk.pack(a19); 02077 pk.pack(a20); 02078 pk.pack(a21); 02079 pk.pack(a22); 02080 pk.pack(a23); 02081 } 02082 void msgpack_unpack(msgpack::object const& o) 02083 { 02084 if(o.type != msgpack::type::ARRAY) { 02085 printf("throw msgpack::type_error()"); 02086 // throw msgpack::type_error(); 02087 } 02088 const size_t size = o.via.array.size; 02089 if(size > 0) { 02090 msgpack::object *ptr = o.via.array.ptr; 02091 switch(size) { 02092 default: 02093 case 24: ptr[23].convert(a23); 02094 case 23: ptr[22].convert(a22); 02095 case 22: ptr[21].convert(a21); 02096 case 21: ptr[20].convert(a20); 02097 case 20: ptr[19].convert(a19); 02098 case 19: ptr[18].convert(a18); 02099 case 18: ptr[17].convert(a17); 02100 case 17: ptr[16].convert(a16); 02101 case 16: ptr[15].convert(a15); 02102 case 15: ptr[14].convert(a14); 02103 case 14: ptr[13].convert(a13); 02104 case 13: ptr[12].convert(a12); 02105 case 12: ptr[11].convert(a11); 02106 case 11: ptr[10].convert(a10); 02107 case 10: ptr[9].convert(a9); 02108 case 9: ptr[8].convert(a8); 02109 case 8: ptr[7].convert(a7); 02110 case 7: ptr[6].convert(a6); 02111 case 6: ptr[5].convert(a5); 02112 case 5: ptr[4].convert(a4); 02113 case 4: ptr[3].convert(a3); 02114 case 3: ptr[2].convert(a2); 02115 case 2: ptr[1].convert(a1); 02116 case 1: ptr[0].convert(a0); 02117 } 02118 } 02119 } 02120 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 02121 { 02122 o->type = msgpack::type::ARRAY; 02123 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*24)); 02124 o->via.array.size = 24; 02125 02126 o->via.array.ptr[0] = msgpack::object(a0, z); 02127 o->via.array.ptr[1] = msgpack::object(a1, z); 02128 o->via.array.ptr[2] = msgpack::object(a2, z); 02129 o->via.array.ptr[3] = msgpack::object(a3, z); 02130 o->via.array.ptr[4] = msgpack::object(a4, z); 02131 o->via.array.ptr[5] = msgpack::object(a5, z); 02132 o->via.array.ptr[6] = msgpack::object(a6, z); 02133 o->via.array.ptr[7] = msgpack::object(a7, z); 02134 o->via.array.ptr[8] = msgpack::object(a8, z); 02135 o->via.array.ptr[9] = msgpack::object(a9, z); 02136 o->via.array.ptr[10] = msgpack::object(a10, z); 02137 o->via.array.ptr[11] = msgpack::object(a11, z); 02138 o->via.array.ptr[12] = msgpack::object(a12, z); 02139 o->via.array.ptr[13] = msgpack::object(a13, z); 02140 o->via.array.ptr[14] = msgpack::object(a14, z); 02141 o->via.array.ptr[15] = msgpack::object(a15, z); 02142 o->via.array.ptr[16] = msgpack::object(a16, z); 02143 o->via.array.ptr[17] = msgpack::object(a17, z); 02144 o->via.array.ptr[18] = msgpack::object(a18, z); 02145 o->via.array.ptr[19] = msgpack::object(a19, z); 02146 o->via.array.ptr[20] = msgpack::object(a20, z); 02147 o->via.array.ptr[21] = msgpack::object(a21, z); 02148 o->via.array.ptr[22] = msgpack::object(a22, z); 02149 o->via.array.ptr[23] = msgpack::object(a23, z); 02150 } 02151 02152 A0& a0; 02153 A1& a1; 02154 A2& a2; 02155 A3& a3; 02156 A4& a4; 02157 A5& a5; 02158 A6& a6; 02159 A7& a7; 02160 A8& a8; 02161 A9& a9; 02162 A10& a10; 02163 A11& a11; 02164 A12& a12; 02165 A13& a13; 02166 A14& a14; 02167 A15& a15; 02168 A16& a16; 02169 A17& a17; 02170 A18& a18; 02171 A19& a19; 02172 A20& a20; 02173 A21& a21; 02174 A22& a22; 02175 A23& a23; 02176 }; 02177 02178 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> 02179 struct define_array<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> { 02180 typedef define_array<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> value_type; 02181 typedef tuple<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> tuple_type; 02182 define_array(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) : 02183 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) {} 02184 template <typename Packer> 02185 void msgpack_pack(Packer& pk) const 02186 { 02187 pk.pack_array(25); 02188 02189 pk.pack(a0); 02190 pk.pack(a1); 02191 pk.pack(a2); 02192 pk.pack(a3); 02193 pk.pack(a4); 02194 pk.pack(a5); 02195 pk.pack(a6); 02196 pk.pack(a7); 02197 pk.pack(a8); 02198 pk.pack(a9); 02199 pk.pack(a10); 02200 pk.pack(a11); 02201 pk.pack(a12); 02202 pk.pack(a13); 02203 pk.pack(a14); 02204 pk.pack(a15); 02205 pk.pack(a16); 02206 pk.pack(a17); 02207 pk.pack(a18); 02208 pk.pack(a19); 02209 pk.pack(a20); 02210 pk.pack(a21); 02211 pk.pack(a22); 02212 pk.pack(a23); 02213 pk.pack(a24); 02214 } 02215 void msgpack_unpack(msgpack::object const& o) 02216 { 02217 if(o.type != msgpack::type::ARRAY) { 02218 printf("throw msgpack::type_error()"); 02219 // throw msgpack::type_error(); 02220 } 02221 const size_t size = o.via.array.size; 02222 if(size > 0) { 02223 msgpack::object *ptr = o.via.array.ptr; 02224 switch(size) { 02225 default: 02226 case 25: ptr[24].convert(a24); 02227 case 24: ptr[23].convert(a23); 02228 case 23: ptr[22].convert(a22); 02229 case 22: ptr[21].convert(a21); 02230 case 21: ptr[20].convert(a20); 02231 case 20: ptr[19].convert(a19); 02232 case 19: ptr[18].convert(a18); 02233 case 18: ptr[17].convert(a17); 02234 case 17: ptr[16].convert(a16); 02235 case 16: ptr[15].convert(a15); 02236 case 15: ptr[14].convert(a14); 02237 case 14: ptr[13].convert(a13); 02238 case 13: ptr[12].convert(a12); 02239 case 12: ptr[11].convert(a11); 02240 case 11: ptr[10].convert(a10); 02241 case 10: ptr[9].convert(a9); 02242 case 9: ptr[8].convert(a8); 02243 case 8: ptr[7].convert(a7); 02244 case 7: ptr[6].convert(a6); 02245 case 6: ptr[5].convert(a5); 02246 case 5: ptr[4].convert(a4); 02247 case 4: ptr[3].convert(a3); 02248 case 3: ptr[2].convert(a2); 02249 case 2: ptr[1].convert(a1); 02250 case 1: ptr[0].convert(a0); 02251 } 02252 } 02253 } 02254 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 02255 { 02256 o->type = msgpack::type::ARRAY; 02257 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*25)); 02258 o->via.array.size = 25; 02259 02260 o->via.array.ptr[0] = msgpack::object(a0, z); 02261 o->via.array.ptr[1] = msgpack::object(a1, z); 02262 o->via.array.ptr[2] = msgpack::object(a2, z); 02263 o->via.array.ptr[3] = msgpack::object(a3, z); 02264 o->via.array.ptr[4] = msgpack::object(a4, z); 02265 o->via.array.ptr[5] = msgpack::object(a5, z); 02266 o->via.array.ptr[6] = msgpack::object(a6, z); 02267 o->via.array.ptr[7] = msgpack::object(a7, z); 02268 o->via.array.ptr[8] = msgpack::object(a8, z); 02269 o->via.array.ptr[9] = msgpack::object(a9, z); 02270 o->via.array.ptr[10] = msgpack::object(a10, z); 02271 o->via.array.ptr[11] = msgpack::object(a11, z); 02272 o->via.array.ptr[12] = msgpack::object(a12, z); 02273 o->via.array.ptr[13] = msgpack::object(a13, z); 02274 o->via.array.ptr[14] = msgpack::object(a14, z); 02275 o->via.array.ptr[15] = msgpack::object(a15, z); 02276 o->via.array.ptr[16] = msgpack::object(a16, z); 02277 o->via.array.ptr[17] = msgpack::object(a17, z); 02278 o->via.array.ptr[18] = msgpack::object(a18, z); 02279 o->via.array.ptr[19] = msgpack::object(a19, z); 02280 o->via.array.ptr[20] = msgpack::object(a20, z); 02281 o->via.array.ptr[21] = msgpack::object(a21, z); 02282 o->via.array.ptr[22] = msgpack::object(a22, z); 02283 o->via.array.ptr[23] = msgpack::object(a23, z); 02284 o->via.array.ptr[24] = msgpack::object(a24, z); 02285 } 02286 02287 A0& a0; 02288 A1& a1; 02289 A2& a2; 02290 A3& a3; 02291 A4& a4; 02292 A5& a5; 02293 A6& a6; 02294 A7& a7; 02295 A8& a8; 02296 A9& a9; 02297 A10& a10; 02298 A11& a11; 02299 A12& a12; 02300 A13& a13; 02301 A14& a14; 02302 A15& a15; 02303 A16& a16; 02304 A17& a17; 02305 A18& a18; 02306 A19& a19; 02307 A20& a20; 02308 A21& a21; 02309 A22& a22; 02310 A23& a23; 02311 A24& a24; 02312 }; 02313 02314 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> 02315 struct define_array<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> { 02316 typedef define_array<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> value_type; 02317 typedef tuple<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> tuple_type; 02318 define_array(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) : 02319 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) {} 02320 template <typename Packer> 02321 void msgpack_pack(Packer& pk) const 02322 { 02323 pk.pack_array(26); 02324 02325 pk.pack(a0); 02326 pk.pack(a1); 02327 pk.pack(a2); 02328 pk.pack(a3); 02329 pk.pack(a4); 02330 pk.pack(a5); 02331 pk.pack(a6); 02332 pk.pack(a7); 02333 pk.pack(a8); 02334 pk.pack(a9); 02335 pk.pack(a10); 02336 pk.pack(a11); 02337 pk.pack(a12); 02338 pk.pack(a13); 02339 pk.pack(a14); 02340 pk.pack(a15); 02341 pk.pack(a16); 02342 pk.pack(a17); 02343 pk.pack(a18); 02344 pk.pack(a19); 02345 pk.pack(a20); 02346 pk.pack(a21); 02347 pk.pack(a22); 02348 pk.pack(a23); 02349 pk.pack(a24); 02350 pk.pack(a25); 02351 } 02352 void msgpack_unpack(msgpack::object const& o) 02353 { 02354 if(o.type != msgpack::type::ARRAY) { 02355 printf("throw msgpack::type_error()"); 02356 // throw msgpack::type_error(); 02357 } 02358 const size_t size = o.via.array.size; 02359 if(size > 0) { 02360 msgpack::object *ptr = o.via.array.ptr; 02361 switch(size) { 02362 default: 02363 case 26: ptr[25].convert(a25); 02364 case 25: ptr[24].convert(a24); 02365 case 24: ptr[23].convert(a23); 02366 case 23: ptr[22].convert(a22); 02367 case 22: ptr[21].convert(a21); 02368 case 21: ptr[20].convert(a20); 02369 case 20: ptr[19].convert(a19); 02370 case 19: ptr[18].convert(a18); 02371 case 18: ptr[17].convert(a17); 02372 case 17: ptr[16].convert(a16); 02373 case 16: ptr[15].convert(a15); 02374 case 15: ptr[14].convert(a14); 02375 case 14: ptr[13].convert(a13); 02376 case 13: ptr[12].convert(a12); 02377 case 12: ptr[11].convert(a11); 02378 case 11: ptr[10].convert(a10); 02379 case 10: ptr[9].convert(a9); 02380 case 9: ptr[8].convert(a8); 02381 case 8: ptr[7].convert(a7); 02382 case 7: ptr[6].convert(a6); 02383 case 6: ptr[5].convert(a5); 02384 case 5: ptr[4].convert(a4); 02385 case 4: ptr[3].convert(a3); 02386 case 3: ptr[2].convert(a2); 02387 case 2: ptr[1].convert(a1); 02388 case 1: ptr[0].convert(a0); 02389 } 02390 } 02391 } 02392 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 02393 { 02394 o->type = msgpack::type::ARRAY; 02395 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*26)); 02396 o->via.array.size = 26; 02397 02398 o->via.array.ptr[0] = msgpack::object(a0, z); 02399 o->via.array.ptr[1] = msgpack::object(a1, z); 02400 o->via.array.ptr[2] = msgpack::object(a2, z); 02401 o->via.array.ptr[3] = msgpack::object(a3, z); 02402 o->via.array.ptr[4] = msgpack::object(a4, z); 02403 o->via.array.ptr[5] = msgpack::object(a5, z); 02404 o->via.array.ptr[6] = msgpack::object(a6, z); 02405 o->via.array.ptr[7] = msgpack::object(a7, z); 02406 o->via.array.ptr[8] = msgpack::object(a8, z); 02407 o->via.array.ptr[9] = msgpack::object(a9, z); 02408 o->via.array.ptr[10] = msgpack::object(a10, z); 02409 o->via.array.ptr[11] = msgpack::object(a11, z); 02410 o->via.array.ptr[12] = msgpack::object(a12, z); 02411 o->via.array.ptr[13] = msgpack::object(a13, z); 02412 o->via.array.ptr[14] = msgpack::object(a14, z); 02413 o->via.array.ptr[15] = msgpack::object(a15, z); 02414 o->via.array.ptr[16] = msgpack::object(a16, z); 02415 o->via.array.ptr[17] = msgpack::object(a17, z); 02416 o->via.array.ptr[18] = msgpack::object(a18, z); 02417 o->via.array.ptr[19] = msgpack::object(a19, z); 02418 o->via.array.ptr[20] = msgpack::object(a20, z); 02419 o->via.array.ptr[21] = msgpack::object(a21, z); 02420 o->via.array.ptr[22] = msgpack::object(a22, z); 02421 o->via.array.ptr[23] = msgpack::object(a23, z); 02422 o->via.array.ptr[24] = msgpack::object(a24, z); 02423 o->via.array.ptr[25] = msgpack::object(a25, z); 02424 } 02425 02426 A0& a0; 02427 A1& a1; 02428 A2& a2; 02429 A3& a3; 02430 A4& a4; 02431 A5& a5; 02432 A6& a6; 02433 A7& a7; 02434 A8& a8; 02435 A9& a9; 02436 A10& a10; 02437 A11& a11; 02438 A12& a12; 02439 A13& a13; 02440 A14& a14; 02441 A15& a15; 02442 A16& a16; 02443 A17& a17; 02444 A18& a18; 02445 A19& a19; 02446 A20& a20; 02447 A21& a21; 02448 A22& a22; 02449 A23& a23; 02450 A24& a24; 02451 A25& a25; 02452 }; 02453 02454 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> 02455 struct define_array<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> { 02456 typedef define_array<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> value_type; 02457 typedef tuple<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> tuple_type; 02458 define_array(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) : 02459 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) {} 02460 template <typename Packer> 02461 void msgpack_pack(Packer& pk) const 02462 { 02463 pk.pack_array(27); 02464 02465 pk.pack(a0); 02466 pk.pack(a1); 02467 pk.pack(a2); 02468 pk.pack(a3); 02469 pk.pack(a4); 02470 pk.pack(a5); 02471 pk.pack(a6); 02472 pk.pack(a7); 02473 pk.pack(a8); 02474 pk.pack(a9); 02475 pk.pack(a10); 02476 pk.pack(a11); 02477 pk.pack(a12); 02478 pk.pack(a13); 02479 pk.pack(a14); 02480 pk.pack(a15); 02481 pk.pack(a16); 02482 pk.pack(a17); 02483 pk.pack(a18); 02484 pk.pack(a19); 02485 pk.pack(a20); 02486 pk.pack(a21); 02487 pk.pack(a22); 02488 pk.pack(a23); 02489 pk.pack(a24); 02490 pk.pack(a25); 02491 pk.pack(a26); 02492 } 02493 void msgpack_unpack(msgpack::object const& o) 02494 { 02495 if(o.type != msgpack::type::ARRAY) { 02496 printf("throw msgpack::type_error()"); 02497 // throw msgpack::type_error(); 02498 } 02499 const size_t size = o.via.array.size; 02500 if(size > 0) { 02501 msgpack::object *ptr = o.via.array.ptr; 02502 switch(size) { 02503 default: 02504 case 27: ptr[26].convert(a26); 02505 case 26: ptr[25].convert(a25); 02506 case 25: ptr[24].convert(a24); 02507 case 24: ptr[23].convert(a23); 02508 case 23: ptr[22].convert(a22); 02509 case 22: ptr[21].convert(a21); 02510 case 21: ptr[20].convert(a20); 02511 case 20: ptr[19].convert(a19); 02512 case 19: ptr[18].convert(a18); 02513 case 18: ptr[17].convert(a17); 02514 case 17: ptr[16].convert(a16); 02515 case 16: ptr[15].convert(a15); 02516 case 15: ptr[14].convert(a14); 02517 case 14: ptr[13].convert(a13); 02518 case 13: ptr[12].convert(a12); 02519 case 12: ptr[11].convert(a11); 02520 case 11: ptr[10].convert(a10); 02521 case 10: ptr[9].convert(a9); 02522 case 9: ptr[8].convert(a8); 02523 case 8: ptr[7].convert(a7); 02524 case 7: ptr[6].convert(a6); 02525 case 6: ptr[5].convert(a5); 02526 case 5: ptr[4].convert(a4); 02527 case 4: ptr[3].convert(a3); 02528 case 3: ptr[2].convert(a2); 02529 case 2: ptr[1].convert(a1); 02530 case 1: ptr[0].convert(a0); 02531 } 02532 } 02533 } 02534 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 02535 { 02536 o->type = msgpack::type::ARRAY; 02537 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*27)); 02538 o->via.array.size = 27; 02539 02540 o->via.array.ptr[0] = msgpack::object(a0, z); 02541 o->via.array.ptr[1] = msgpack::object(a1, z); 02542 o->via.array.ptr[2] = msgpack::object(a2, z); 02543 o->via.array.ptr[3] = msgpack::object(a3, z); 02544 o->via.array.ptr[4] = msgpack::object(a4, z); 02545 o->via.array.ptr[5] = msgpack::object(a5, z); 02546 o->via.array.ptr[6] = msgpack::object(a6, z); 02547 o->via.array.ptr[7] = msgpack::object(a7, z); 02548 o->via.array.ptr[8] = msgpack::object(a8, z); 02549 o->via.array.ptr[9] = msgpack::object(a9, z); 02550 o->via.array.ptr[10] = msgpack::object(a10, z); 02551 o->via.array.ptr[11] = msgpack::object(a11, z); 02552 o->via.array.ptr[12] = msgpack::object(a12, z); 02553 o->via.array.ptr[13] = msgpack::object(a13, z); 02554 o->via.array.ptr[14] = msgpack::object(a14, z); 02555 o->via.array.ptr[15] = msgpack::object(a15, z); 02556 o->via.array.ptr[16] = msgpack::object(a16, z); 02557 o->via.array.ptr[17] = msgpack::object(a17, z); 02558 o->via.array.ptr[18] = msgpack::object(a18, z); 02559 o->via.array.ptr[19] = msgpack::object(a19, z); 02560 o->via.array.ptr[20] = msgpack::object(a20, z); 02561 o->via.array.ptr[21] = msgpack::object(a21, z); 02562 o->via.array.ptr[22] = msgpack::object(a22, z); 02563 o->via.array.ptr[23] = msgpack::object(a23, z); 02564 o->via.array.ptr[24] = msgpack::object(a24, z); 02565 o->via.array.ptr[25] = msgpack::object(a25, z); 02566 o->via.array.ptr[26] = msgpack::object(a26, z); 02567 } 02568 02569 A0& a0; 02570 A1& a1; 02571 A2& a2; 02572 A3& a3; 02573 A4& a4; 02574 A5& a5; 02575 A6& a6; 02576 A7& a7; 02577 A8& a8; 02578 A9& a9; 02579 A10& a10; 02580 A11& a11; 02581 A12& a12; 02582 A13& a13; 02583 A14& a14; 02584 A15& a15; 02585 A16& a16; 02586 A17& a17; 02587 A18& a18; 02588 A19& a19; 02589 A20& a20; 02590 A21& a21; 02591 A22& a22; 02592 A23& a23; 02593 A24& a24; 02594 A25& a25; 02595 A26& a26; 02596 }; 02597 02598 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> 02599 struct define_array<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> { 02600 typedef define_array<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> value_type; 02601 typedef tuple<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> tuple_type; 02602 define_array(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) : 02603 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) {} 02604 template <typename Packer> 02605 void msgpack_pack(Packer& pk) const 02606 { 02607 pk.pack_array(28); 02608 02609 pk.pack(a0); 02610 pk.pack(a1); 02611 pk.pack(a2); 02612 pk.pack(a3); 02613 pk.pack(a4); 02614 pk.pack(a5); 02615 pk.pack(a6); 02616 pk.pack(a7); 02617 pk.pack(a8); 02618 pk.pack(a9); 02619 pk.pack(a10); 02620 pk.pack(a11); 02621 pk.pack(a12); 02622 pk.pack(a13); 02623 pk.pack(a14); 02624 pk.pack(a15); 02625 pk.pack(a16); 02626 pk.pack(a17); 02627 pk.pack(a18); 02628 pk.pack(a19); 02629 pk.pack(a20); 02630 pk.pack(a21); 02631 pk.pack(a22); 02632 pk.pack(a23); 02633 pk.pack(a24); 02634 pk.pack(a25); 02635 pk.pack(a26); 02636 pk.pack(a27); 02637 } 02638 void msgpack_unpack(msgpack::object const& o) 02639 { 02640 if(o.type != msgpack::type::ARRAY) { 02641 printf("throw msgpack::type_error()"); 02642 // throw msgpack::type_error(); 02643 } 02644 const size_t size = o.via.array.size; 02645 if(size > 0) { 02646 msgpack::object *ptr = o.via.array.ptr; 02647 switch(size) { 02648 default: 02649 case 28: ptr[27].convert(a27); 02650 case 27: ptr[26].convert(a26); 02651 case 26: ptr[25].convert(a25); 02652 case 25: ptr[24].convert(a24); 02653 case 24: ptr[23].convert(a23); 02654 case 23: ptr[22].convert(a22); 02655 case 22: ptr[21].convert(a21); 02656 case 21: ptr[20].convert(a20); 02657 case 20: ptr[19].convert(a19); 02658 case 19: ptr[18].convert(a18); 02659 case 18: ptr[17].convert(a17); 02660 case 17: ptr[16].convert(a16); 02661 case 16: ptr[15].convert(a15); 02662 case 15: ptr[14].convert(a14); 02663 case 14: ptr[13].convert(a13); 02664 case 13: ptr[12].convert(a12); 02665 case 12: ptr[11].convert(a11); 02666 case 11: ptr[10].convert(a10); 02667 case 10: ptr[9].convert(a9); 02668 case 9: ptr[8].convert(a8); 02669 case 8: ptr[7].convert(a7); 02670 case 7: ptr[6].convert(a6); 02671 case 6: ptr[5].convert(a5); 02672 case 5: ptr[4].convert(a4); 02673 case 4: ptr[3].convert(a3); 02674 case 3: ptr[2].convert(a2); 02675 case 2: ptr[1].convert(a1); 02676 case 1: ptr[0].convert(a0); 02677 } 02678 } 02679 } 02680 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 02681 { 02682 o->type = msgpack::type::ARRAY; 02683 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*28)); 02684 o->via.array.size = 28; 02685 02686 o->via.array.ptr[0] = msgpack::object(a0, z); 02687 o->via.array.ptr[1] = msgpack::object(a1, z); 02688 o->via.array.ptr[2] = msgpack::object(a2, z); 02689 o->via.array.ptr[3] = msgpack::object(a3, z); 02690 o->via.array.ptr[4] = msgpack::object(a4, z); 02691 o->via.array.ptr[5] = msgpack::object(a5, z); 02692 o->via.array.ptr[6] = msgpack::object(a6, z); 02693 o->via.array.ptr[7] = msgpack::object(a7, z); 02694 o->via.array.ptr[8] = msgpack::object(a8, z); 02695 o->via.array.ptr[9] = msgpack::object(a9, z); 02696 o->via.array.ptr[10] = msgpack::object(a10, z); 02697 o->via.array.ptr[11] = msgpack::object(a11, z); 02698 o->via.array.ptr[12] = msgpack::object(a12, z); 02699 o->via.array.ptr[13] = msgpack::object(a13, z); 02700 o->via.array.ptr[14] = msgpack::object(a14, z); 02701 o->via.array.ptr[15] = msgpack::object(a15, z); 02702 o->via.array.ptr[16] = msgpack::object(a16, z); 02703 o->via.array.ptr[17] = msgpack::object(a17, z); 02704 o->via.array.ptr[18] = msgpack::object(a18, z); 02705 o->via.array.ptr[19] = msgpack::object(a19, z); 02706 o->via.array.ptr[20] = msgpack::object(a20, z); 02707 o->via.array.ptr[21] = msgpack::object(a21, z); 02708 o->via.array.ptr[22] = msgpack::object(a22, z); 02709 o->via.array.ptr[23] = msgpack::object(a23, z); 02710 o->via.array.ptr[24] = msgpack::object(a24, z); 02711 o->via.array.ptr[25] = msgpack::object(a25, z); 02712 o->via.array.ptr[26] = msgpack::object(a26, z); 02713 o->via.array.ptr[27] = msgpack::object(a27, z); 02714 } 02715 02716 A0& a0; 02717 A1& a1; 02718 A2& a2; 02719 A3& a3; 02720 A4& a4; 02721 A5& a5; 02722 A6& a6; 02723 A7& a7; 02724 A8& a8; 02725 A9& a9; 02726 A10& a10; 02727 A11& a11; 02728 A12& a12; 02729 A13& a13; 02730 A14& a14; 02731 A15& a15; 02732 A16& a16; 02733 A17& a17; 02734 A18& a18; 02735 A19& a19; 02736 A20& a20; 02737 A21& a21; 02738 A22& a22; 02739 A23& a23; 02740 A24& a24; 02741 A25& a25; 02742 A26& a26; 02743 A27& a27; 02744 }; 02745 02746 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> 02747 struct define_array<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> { 02748 typedef define_array<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> value_type; 02749 typedef tuple<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> tuple_type; 02750 define_array(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) : 02751 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) {} 02752 template <typename Packer> 02753 void msgpack_pack(Packer& pk) const 02754 { 02755 pk.pack_array(29); 02756 02757 pk.pack(a0); 02758 pk.pack(a1); 02759 pk.pack(a2); 02760 pk.pack(a3); 02761 pk.pack(a4); 02762 pk.pack(a5); 02763 pk.pack(a6); 02764 pk.pack(a7); 02765 pk.pack(a8); 02766 pk.pack(a9); 02767 pk.pack(a10); 02768 pk.pack(a11); 02769 pk.pack(a12); 02770 pk.pack(a13); 02771 pk.pack(a14); 02772 pk.pack(a15); 02773 pk.pack(a16); 02774 pk.pack(a17); 02775 pk.pack(a18); 02776 pk.pack(a19); 02777 pk.pack(a20); 02778 pk.pack(a21); 02779 pk.pack(a22); 02780 pk.pack(a23); 02781 pk.pack(a24); 02782 pk.pack(a25); 02783 pk.pack(a26); 02784 pk.pack(a27); 02785 pk.pack(a28); 02786 } 02787 void msgpack_unpack(msgpack::object const& o) 02788 { 02789 if(o.type != msgpack::type::ARRAY) { 02790 printf("throw msgpack::type_error()"); 02791 // throw msgpack::type_error(); 02792 } 02793 const size_t size = o.via.array.size; 02794 if(size > 0) { 02795 msgpack::object *ptr = o.via.array.ptr; 02796 switch(size) { 02797 default: 02798 case 29: ptr[28].convert(a28); 02799 case 28: ptr[27].convert(a27); 02800 case 27: ptr[26].convert(a26); 02801 case 26: ptr[25].convert(a25); 02802 case 25: ptr[24].convert(a24); 02803 case 24: ptr[23].convert(a23); 02804 case 23: ptr[22].convert(a22); 02805 case 22: ptr[21].convert(a21); 02806 case 21: ptr[20].convert(a20); 02807 case 20: ptr[19].convert(a19); 02808 case 19: ptr[18].convert(a18); 02809 case 18: ptr[17].convert(a17); 02810 case 17: ptr[16].convert(a16); 02811 case 16: ptr[15].convert(a15); 02812 case 15: ptr[14].convert(a14); 02813 case 14: ptr[13].convert(a13); 02814 case 13: ptr[12].convert(a12); 02815 case 12: ptr[11].convert(a11); 02816 case 11: ptr[10].convert(a10); 02817 case 10: ptr[9].convert(a9); 02818 case 9: ptr[8].convert(a8); 02819 case 8: ptr[7].convert(a7); 02820 case 7: ptr[6].convert(a6); 02821 case 6: ptr[5].convert(a5); 02822 case 5: ptr[4].convert(a4); 02823 case 4: ptr[3].convert(a3); 02824 case 3: ptr[2].convert(a2); 02825 case 2: ptr[1].convert(a1); 02826 case 1: ptr[0].convert(a0); 02827 } 02828 } 02829 } 02830 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 02831 { 02832 o->type = msgpack::type::ARRAY; 02833 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*29)); 02834 o->via.array.size = 29; 02835 02836 o->via.array.ptr[0] = msgpack::object(a0, z); 02837 o->via.array.ptr[1] = msgpack::object(a1, z); 02838 o->via.array.ptr[2] = msgpack::object(a2, z); 02839 o->via.array.ptr[3] = msgpack::object(a3, z); 02840 o->via.array.ptr[4] = msgpack::object(a4, z); 02841 o->via.array.ptr[5] = msgpack::object(a5, z); 02842 o->via.array.ptr[6] = msgpack::object(a6, z); 02843 o->via.array.ptr[7] = msgpack::object(a7, z); 02844 o->via.array.ptr[8] = msgpack::object(a8, z); 02845 o->via.array.ptr[9] = msgpack::object(a9, z); 02846 o->via.array.ptr[10] = msgpack::object(a10, z); 02847 o->via.array.ptr[11] = msgpack::object(a11, z); 02848 o->via.array.ptr[12] = msgpack::object(a12, z); 02849 o->via.array.ptr[13] = msgpack::object(a13, z); 02850 o->via.array.ptr[14] = msgpack::object(a14, z); 02851 o->via.array.ptr[15] = msgpack::object(a15, z); 02852 o->via.array.ptr[16] = msgpack::object(a16, z); 02853 o->via.array.ptr[17] = msgpack::object(a17, z); 02854 o->via.array.ptr[18] = msgpack::object(a18, z); 02855 o->via.array.ptr[19] = msgpack::object(a19, z); 02856 o->via.array.ptr[20] = msgpack::object(a20, z); 02857 o->via.array.ptr[21] = msgpack::object(a21, z); 02858 o->via.array.ptr[22] = msgpack::object(a22, z); 02859 o->via.array.ptr[23] = msgpack::object(a23, z); 02860 o->via.array.ptr[24] = msgpack::object(a24, z); 02861 o->via.array.ptr[25] = msgpack::object(a25, z); 02862 o->via.array.ptr[26] = msgpack::object(a26, z); 02863 o->via.array.ptr[27] = msgpack::object(a27, z); 02864 o->via.array.ptr[28] = msgpack::object(a28, z); 02865 } 02866 02867 A0& a0; 02868 A1& a1; 02869 A2& a2; 02870 A3& a3; 02871 A4& a4; 02872 A5& a5; 02873 A6& a6; 02874 A7& a7; 02875 A8& a8; 02876 A9& a9; 02877 A10& a10; 02878 A11& a11; 02879 A12& a12; 02880 A13& a13; 02881 A14& a14; 02882 A15& a15; 02883 A16& a16; 02884 A17& a17; 02885 A18& a18; 02886 A19& a19; 02887 A20& a20; 02888 A21& a21; 02889 A22& a22; 02890 A23& a23; 02891 A24& a24; 02892 A25& a25; 02893 A26& a26; 02894 A27& a27; 02895 A28& a28; 02896 }; 02897 02898 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> 02899 struct define_array<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> { 02900 typedef define_array<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> value_type; 02901 typedef tuple<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> tuple_type; 02902 define_array(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) : 02903 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) {} 02904 template <typename Packer> 02905 void msgpack_pack(Packer& pk) const 02906 { 02907 pk.pack_array(30); 02908 02909 pk.pack(a0); 02910 pk.pack(a1); 02911 pk.pack(a2); 02912 pk.pack(a3); 02913 pk.pack(a4); 02914 pk.pack(a5); 02915 pk.pack(a6); 02916 pk.pack(a7); 02917 pk.pack(a8); 02918 pk.pack(a9); 02919 pk.pack(a10); 02920 pk.pack(a11); 02921 pk.pack(a12); 02922 pk.pack(a13); 02923 pk.pack(a14); 02924 pk.pack(a15); 02925 pk.pack(a16); 02926 pk.pack(a17); 02927 pk.pack(a18); 02928 pk.pack(a19); 02929 pk.pack(a20); 02930 pk.pack(a21); 02931 pk.pack(a22); 02932 pk.pack(a23); 02933 pk.pack(a24); 02934 pk.pack(a25); 02935 pk.pack(a26); 02936 pk.pack(a27); 02937 pk.pack(a28); 02938 pk.pack(a29); 02939 } 02940 void msgpack_unpack(msgpack::object const& o) 02941 { 02942 if(o.type != msgpack::type::ARRAY) { 02943 printf("throw msgpack::type_error()"); 02944 // throw msgpack::type_error(); 02945 } 02946 const size_t size = o.via.array.size; 02947 if(size > 0) { 02948 msgpack::object *ptr = o.via.array.ptr; 02949 switch(size) { 02950 default: 02951 case 30: ptr[29].convert(a29); 02952 case 29: ptr[28].convert(a28); 02953 case 28: ptr[27].convert(a27); 02954 case 27: ptr[26].convert(a26); 02955 case 26: ptr[25].convert(a25); 02956 case 25: ptr[24].convert(a24); 02957 case 24: ptr[23].convert(a23); 02958 case 23: ptr[22].convert(a22); 02959 case 22: ptr[21].convert(a21); 02960 case 21: ptr[20].convert(a20); 02961 case 20: ptr[19].convert(a19); 02962 case 19: ptr[18].convert(a18); 02963 case 18: ptr[17].convert(a17); 02964 case 17: ptr[16].convert(a16); 02965 case 16: ptr[15].convert(a15); 02966 case 15: ptr[14].convert(a14); 02967 case 14: ptr[13].convert(a13); 02968 case 13: ptr[12].convert(a12); 02969 case 12: ptr[11].convert(a11); 02970 case 11: ptr[10].convert(a10); 02971 case 10: ptr[9].convert(a9); 02972 case 9: ptr[8].convert(a8); 02973 case 8: ptr[7].convert(a7); 02974 case 7: ptr[6].convert(a6); 02975 case 6: ptr[5].convert(a5); 02976 case 5: ptr[4].convert(a4); 02977 case 4: ptr[3].convert(a3); 02978 case 3: ptr[2].convert(a2); 02979 case 2: ptr[1].convert(a1); 02980 case 1: ptr[0].convert(a0); 02981 } 02982 } 02983 } 02984 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 02985 { 02986 o->type = msgpack::type::ARRAY; 02987 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*30)); 02988 o->via.array.size = 30; 02989 02990 o->via.array.ptr[0] = msgpack::object(a0, z); 02991 o->via.array.ptr[1] = msgpack::object(a1, z); 02992 o->via.array.ptr[2] = msgpack::object(a2, z); 02993 o->via.array.ptr[3] = msgpack::object(a3, z); 02994 o->via.array.ptr[4] = msgpack::object(a4, z); 02995 o->via.array.ptr[5] = msgpack::object(a5, z); 02996 o->via.array.ptr[6] = msgpack::object(a6, z); 02997 o->via.array.ptr[7] = msgpack::object(a7, z); 02998 o->via.array.ptr[8] = msgpack::object(a8, z); 02999 o->via.array.ptr[9] = msgpack::object(a9, z); 03000 o->via.array.ptr[10] = msgpack::object(a10, z); 03001 o->via.array.ptr[11] = msgpack::object(a11, z); 03002 o->via.array.ptr[12] = msgpack::object(a12, z); 03003 o->via.array.ptr[13] = msgpack::object(a13, z); 03004 o->via.array.ptr[14] = msgpack::object(a14, z); 03005 o->via.array.ptr[15] = msgpack::object(a15, z); 03006 o->via.array.ptr[16] = msgpack::object(a16, z); 03007 o->via.array.ptr[17] = msgpack::object(a17, z); 03008 o->via.array.ptr[18] = msgpack::object(a18, z); 03009 o->via.array.ptr[19] = msgpack::object(a19, z); 03010 o->via.array.ptr[20] = msgpack::object(a20, z); 03011 o->via.array.ptr[21] = msgpack::object(a21, z); 03012 o->via.array.ptr[22] = msgpack::object(a22, z); 03013 o->via.array.ptr[23] = msgpack::object(a23, z); 03014 o->via.array.ptr[24] = msgpack::object(a24, z); 03015 o->via.array.ptr[25] = msgpack::object(a25, z); 03016 o->via.array.ptr[26] = msgpack::object(a26, z); 03017 o->via.array.ptr[27] = msgpack::object(a27, z); 03018 o->via.array.ptr[28] = msgpack::object(a28, z); 03019 o->via.array.ptr[29] = msgpack::object(a29, z); 03020 } 03021 03022 A0& a0; 03023 A1& a1; 03024 A2& a2; 03025 A3& a3; 03026 A4& a4; 03027 A5& a5; 03028 A6& a6; 03029 A7& a7; 03030 A8& a8; 03031 A9& a9; 03032 A10& a10; 03033 A11& a11; 03034 A12& a12; 03035 A13& a13; 03036 A14& a14; 03037 A15& a15; 03038 A16& a16; 03039 A17& a17; 03040 A18& a18; 03041 A19& a19; 03042 A20& a20; 03043 A21& a21; 03044 A22& a22; 03045 A23& a23; 03046 A24& a24; 03047 A25& a25; 03048 A26& a26; 03049 A27& a27; 03050 A28& a28; 03051 A29& a29; 03052 }; 03053 03054 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> 03055 struct define_array<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> { 03056 typedef define_array<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> value_type; 03057 typedef tuple<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> tuple_type; 03058 define_array(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) : 03059 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) {} 03060 template <typename Packer> 03061 void msgpack_pack(Packer& pk) const 03062 { 03063 pk.pack_array(31); 03064 03065 pk.pack(a0); 03066 pk.pack(a1); 03067 pk.pack(a2); 03068 pk.pack(a3); 03069 pk.pack(a4); 03070 pk.pack(a5); 03071 pk.pack(a6); 03072 pk.pack(a7); 03073 pk.pack(a8); 03074 pk.pack(a9); 03075 pk.pack(a10); 03076 pk.pack(a11); 03077 pk.pack(a12); 03078 pk.pack(a13); 03079 pk.pack(a14); 03080 pk.pack(a15); 03081 pk.pack(a16); 03082 pk.pack(a17); 03083 pk.pack(a18); 03084 pk.pack(a19); 03085 pk.pack(a20); 03086 pk.pack(a21); 03087 pk.pack(a22); 03088 pk.pack(a23); 03089 pk.pack(a24); 03090 pk.pack(a25); 03091 pk.pack(a26); 03092 pk.pack(a27); 03093 pk.pack(a28); 03094 pk.pack(a29); 03095 pk.pack(a30); 03096 } 03097 void msgpack_unpack(msgpack::object const& o) 03098 { 03099 if(o.type != msgpack::type::ARRAY) { 03100 printf("throw msgpack::type_error()"); 03101 // throw msgpack::type_error(); 03102 } 03103 const size_t size = o.via.array.size; 03104 if(size > 0) { 03105 msgpack::object *ptr = o.via.array.ptr; 03106 switch(size) { 03107 default: 03108 case 31: ptr[30].convert(a30); 03109 case 30: ptr[29].convert(a29); 03110 case 29: ptr[28].convert(a28); 03111 case 28: ptr[27].convert(a27); 03112 case 27: ptr[26].convert(a26); 03113 case 26: ptr[25].convert(a25); 03114 case 25: ptr[24].convert(a24); 03115 case 24: ptr[23].convert(a23); 03116 case 23: ptr[22].convert(a22); 03117 case 22: ptr[21].convert(a21); 03118 case 21: ptr[20].convert(a20); 03119 case 20: ptr[19].convert(a19); 03120 case 19: ptr[18].convert(a18); 03121 case 18: ptr[17].convert(a17); 03122 case 17: ptr[16].convert(a16); 03123 case 16: ptr[15].convert(a15); 03124 case 15: ptr[14].convert(a14); 03125 case 14: ptr[13].convert(a13); 03126 case 13: ptr[12].convert(a12); 03127 case 12: ptr[11].convert(a11); 03128 case 11: ptr[10].convert(a10); 03129 case 10: ptr[9].convert(a9); 03130 case 9: ptr[8].convert(a8); 03131 case 8: ptr[7].convert(a7); 03132 case 7: ptr[6].convert(a6); 03133 case 6: ptr[5].convert(a5); 03134 case 5: ptr[4].convert(a4); 03135 case 4: ptr[3].convert(a3); 03136 case 3: ptr[2].convert(a2); 03137 case 2: ptr[1].convert(a1); 03138 case 1: ptr[0].convert(a0); 03139 } 03140 } 03141 } 03142 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 03143 { 03144 o->type = msgpack::type::ARRAY; 03145 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*31)); 03146 o->via.array.size = 31; 03147 03148 o->via.array.ptr[0] = msgpack::object(a0, z); 03149 o->via.array.ptr[1] = msgpack::object(a1, z); 03150 o->via.array.ptr[2] = msgpack::object(a2, z); 03151 o->via.array.ptr[3] = msgpack::object(a3, z); 03152 o->via.array.ptr[4] = msgpack::object(a4, z); 03153 o->via.array.ptr[5] = msgpack::object(a5, z); 03154 o->via.array.ptr[6] = msgpack::object(a6, z); 03155 o->via.array.ptr[7] = msgpack::object(a7, z); 03156 o->via.array.ptr[8] = msgpack::object(a8, z); 03157 o->via.array.ptr[9] = msgpack::object(a9, z); 03158 o->via.array.ptr[10] = msgpack::object(a10, z); 03159 o->via.array.ptr[11] = msgpack::object(a11, z); 03160 o->via.array.ptr[12] = msgpack::object(a12, z); 03161 o->via.array.ptr[13] = msgpack::object(a13, z); 03162 o->via.array.ptr[14] = msgpack::object(a14, z); 03163 o->via.array.ptr[15] = msgpack::object(a15, z); 03164 o->via.array.ptr[16] = msgpack::object(a16, z); 03165 o->via.array.ptr[17] = msgpack::object(a17, z); 03166 o->via.array.ptr[18] = msgpack::object(a18, z); 03167 o->via.array.ptr[19] = msgpack::object(a19, z); 03168 o->via.array.ptr[20] = msgpack::object(a20, z); 03169 o->via.array.ptr[21] = msgpack::object(a21, z); 03170 o->via.array.ptr[22] = msgpack::object(a22, z); 03171 o->via.array.ptr[23] = msgpack::object(a23, z); 03172 o->via.array.ptr[24] = msgpack::object(a24, z); 03173 o->via.array.ptr[25] = msgpack::object(a25, z); 03174 o->via.array.ptr[26] = msgpack::object(a26, z); 03175 o->via.array.ptr[27] = msgpack::object(a27, z); 03176 o->via.array.ptr[28] = msgpack::object(a28, z); 03177 o->via.array.ptr[29] = msgpack::object(a29, z); 03178 o->via.array.ptr[30] = msgpack::object(a30, z); 03179 } 03180 03181 A0& a0; 03182 A1& a1; 03183 A2& a2; 03184 A3& a3; 03185 A4& a4; 03186 A5& a5; 03187 A6& a6; 03188 A7& a7; 03189 A8& a8; 03190 A9& a9; 03191 A10& a10; 03192 A11& a11; 03193 A12& a12; 03194 A13& a13; 03195 A14& a14; 03196 A15& a15; 03197 A16& a16; 03198 A17& a17; 03199 A18& a18; 03200 A19& a19; 03201 A20& a20; 03202 A21& a21; 03203 A22& a22; 03204 A23& a23; 03205 A24& a24; 03206 A25& a25; 03207 A26& a26; 03208 A27& a27; 03209 A28& a28; 03210 A29& a29; 03211 A30& a30; 03212 }; 03213 03214 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> 03215 struct define_array<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> { 03216 typedef define_array<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> value_type; 03217 typedef tuple<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> tuple_type; 03218 define_array(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) : 03219 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) {} 03220 template <typename Packer> 03221 void msgpack_pack(Packer& pk) const 03222 { 03223 pk.pack_array(32); 03224 03225 pk.pack(a0); 03226 pk.pack(a1); 03227 pk.pack(a2); 03228 pk.pack(a3); 03229 pk.pack(a4); 03230 pk.pack(a5); 03231 pk.pack(a6); 03232 pk.pack(a7); 03233 pk.pack(a8); 03234 pk.pack(a9); 03235 pk.pack(a10); 03236 pk.pack(a11); 03237 pk.pack(a12); 03238 pk.pack(a13); 03239 pk.pack(a14); 03240 pk.pack(a15); 03241 pk.pack(a16); 03242 pk.pack(a17); 03243 pk.pack(a18); 03244 pk.pack(a19); 03245 pk.pack(a20); 03246 pk.pack(a21); 03247 pk.pack(a22); 03248 pk.pack(a23); 03249 pk.pack(a24); 03250 pk.pack(a25); 03251 pk.pack(a26); 03252 pk.pack(a27); 03253 pk.pack(a28); 03254 pk.pack(a29); 03255 pk.pack(a30); 03256 pk.pack(a31); 03257 } 03258 void msgpack_unpack(msgpack::object const& o) 03259 { 03260 if(o.type != msgpack::type::ARRAY) { 03261 printf("throw msgpack::type_error()"); 03262 // throw msgpack::type_error(); 03263 } 03264 const size_t size = o.via.array.size; 03265 if(size > 0) { 03266 msgpack::object *ptr = o.via.array.ptr; 03267 switch(size) { 03268 default: 03269 case 32: ptr[31].convert(a31); 03270 case 31: ptr[30].convert(a30); 03271 case 30: ptr[29].convert(a29); 03272 case 29: ptr[28].convert(a28); 03273 case 28: ptr[27].convert(a27); 03274 case 27: ptr[26].convert(a26); 03275 case 26: ptr[25].convert(a25); 03276 case 25: ptr[24].convert(a24); 03277 case 24: ptr[23].convert(a23); 03278 case 23: ptr[22].convert(a22); 03279 case 22: ptr[21].convert(a21); 03280 case 21: ptr[20].convert(a20); 03281 case 20: ptr[19].convert(a19); 03282 case 19: ptr[18].convert(a18); 03283 case 18: ptr[17].convert(a17); 03284 case 17: ptr[16].convert(a16); 03285 case 16: ptr[15].convert(a15); 03286 case 15: ptr[14].convert(a14); 03287 case 14: ptr[13].convert(a13); 03288 case 13: ptr[12].convert(a12); 03289 case 12: ptr[11].convert(a11); 03290 case 11: ptr[10].convert(a10); 03291 case 10: ptr[9].convert(a9); 03292 case 9: ptr[8].convert(a8); 03293 case 8: ptr[7].convert(a7); 03294 case 7: ptr[6].convert(a6); 03295 case 6: ptr[5].convert(a5); 03296 case 5: ptr[4].convert(a4); 03297 case 4: ptr[3].convert(a3); 03298 case 3: ptr[2].convert(a2); 03299 case 2: ptr[1].convert(a1); 03300 case 1: ptr[0].convert(a0); 03301 } 03302 } 03303 } 03304 void msgpack_object(msgpack::object* o, msgpack::zone& z) const 03305 { 03306 o->type = msgpack::type::ARRAY; 03307 o->via.array.ptr = static_cast<msgpack::object*>(z.allocate_align(sizeof(msgpack::object)*32)); 03308 o->via.array.size = 32; 03309 03310 o->via.array.ptr[0] = msgpack::object(a0, z); 03311 o->via.array.ptr[1] = msgpack::object(a1, z); 03312 o->via.array.ptr[2] = msgpack::object(a2, z); 03313 o->via.array.ptr[3] = msgpack::object(a3, z); 03314 o->via.array.ptr[4] = msgpack::object(a4, z); 03315 o->via.array.ptr[5] = msgpack::object(a5, z); 03316 o->via.array.ptr[6] = msgpack::object(a6, z); 03317 o->via.array.ptr[7] = msgpack::object(a7, z); 03318 o->via.array.ptr[8] = msgpack::object(a8, z); 03319 o->via.array.ptr[9] = msgpack::object(a9, z); 03320 o->via.array.ptr[10] = msgpack::object(a10, z); 03321 o->via.array.ptr[11] = msgpack::object(a11, z); 03322 o->via.array.ptr[12] = msgpack::object(a12, z); 03323 o->via.array.ptr[13] = msgpack::object(a13, z); 03324 o->via.array.ptr[14] = msgpack::object(a14, z); 03325 o->via.array.ptr[15] = msgpack::object(a15, z); 03326 o->via.array.ptr[16] = msgpack::object(a16, z); 03327 o->via.array.ptr[17] = msgpack::object(a17, z); 03328 o->via.array.ptr[18] = msgpack::object(a18, z); 03329 o->via.array.ptr[19] = msgpack::object(a19, z); 03330 o->via.array.ptr[20] = msgpack::object(a20, z); 03331 o->via.array.ptr[21] = msgpack::object(a21, z); 03332 o->via.array.ptr[22] = msgpack::object(a22, z); 03333 o->via.array.ptr[23] = msgpack::object(a23, z); 03334 o->via.array.ptr[24] = msgpack::object(a24, z); 03335 o->via.array.ptr[25] = msgpack::object(a25, z); 03336 o->via.array.ptr[26] = msgpack::object(a26, z); 03337 o->via.array.ptr[27] = msgpack::object(a27, z); 03338 o->via.array.ptr[28] = msgpack::object(a28, z); 03339 o->via.array.ptr[29] = msgpack::object(a29, z); 03340 o->via.array.ptr[30] = msgpack::object(a30, z); 03341 o->via.array.ptr[31] = msgpack::object(a31, z); 03342 } 03343 03344 A0& a0; 03345 A1& a1; 03346 A2& a2; 03347 A3& a3; 03348 A4& a4; 03349 A5& a5; 03350 A6& a6; 03351 A7& a7; 03352 A8& a8; 03353 A9& a9; 03354 A10& a10; 03355 A11& a11; 03356 A12& a12; 03357 A13& a13; 03358 A14& a14; 03359 A15& a15; 03360 A16& a16; 03361 A17& a17; 03362 A18& a18; 03363 A19& a19; 03364 A20& a20; 03365 A21& a21; 03366 A22& a22; 03367 A23& a23; 03368 A24& a24; 03369 A25& a25; 03370 A26& a26; 03371 A27& a27; 03372 A28& a28; 03373 A29& a29; 03374 A30& a30; 03375 A31& a31; 03376 }; 03377 03378 /// @endcond 03379 03380 inline define_array<> make_define_array() 03381 { 03382 return define_array<>(); 03383 } 03384 03385 /// @cond 03386 03387 template <typename A0> 03388 inline define_array<A0> make_define_array(A0& a0) 03389 { 03390 return define_array<A0>(a0); 03391 } 03392 03393 template <typename A0, typename A1> 03394 inline define_array<A0, A1> make_define_array(A0& a0, A1& a1) 03395 { 03396 return define_array<A0, A1>(a0, a1); 03397 } 03398 03399 template <typename A0, typename A1, typename A2> 03400 inline define_array<A0, A1, A2> make_define_array(A0& a0, A1& a1, A2& a2) 03401 { 03402 return define_array<A0, A1, A2>(a0, a1, a2); 03403 } 03404 03405 template <typename A0, typename A1, typename A2, typename A3> 03406 inline define_array<A0, A1, A2, A3> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3) 03407 { 03408 return define_array<A0, A1, A2, A3>(a0, a1, a2, a3); 03409 } 03410 03411 template <typename A0, typename A1, typename A2, typename A3, typename A4> 03412 inline define_array<A0, A1, A2, A3, A4> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) 03413 { 03414 return define_array<A0, A1, A2, A3, A4>(a0, a1, a2, a3, a4); 03415 } 03416 03417 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5> 03418 inline define_array<A0, A1, A2, A3, A4, A5> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) 03419 { 03420 return define_array<A0, A1, A2, A3, A4, A5>(a0, a1, a2, a3, a4, a5); 03421 } 03422 03423 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6> 03424 inline define_array<A0, A1, A2, A3, A4, A5, A6> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) 03425 { 03426 return define_array<A0, A1, A2, A3, A4, A5, A6>(a0, a1, a2, a3, a4, a5, a6); 03427 } 03428 03429 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7> 03430 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) 03431 { 03432 return define_array<A0, A1, A2, A3, A4, A5, A6, A7>(a0, a1, a2, a3, a4, a5, a6, a7); 03433 } 03434 03435 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8> 03436 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) 03437 { 03438 return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8>(a0, a1, a2, a3, a4, a5, a6, a7, a8); 03439 } 03440 03441 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9> 03442 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) 03443 { 03444 return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); 03445 } 03446 03447 template <typename A0, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10> 03448 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) 03449 { 03450 return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); 03451 } 03452 03453 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> 03454 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> make_define_array(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) 03455 { 03456 return define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); 03457 } 03458 03459 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> 03460 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> make_define_array(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) 03461 { 03462 return define_array<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); 03463 } 03464 03465 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> 03466 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> make_define_array(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) 03467 { 03468 return define_array<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); 03469 } 03470 03471 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> 03472 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> make_define_array(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) 03473 { 03474 return define_array<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); 03475 } 03476 03477 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> 03478 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> make_define_array(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) 03479 { 03480 return define_array<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); 03481 } 03482 03483 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> 03484 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> make_define_array(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) 03485 { 03486 return define_array<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); 03487 } 03488 03489 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> 03490 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17> make_define_array(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) 03491 { 03492 return define_array<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); 03493 } 03494 03495 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> 03496 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18> make_define_array(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) 03497 { 03498 return define_array<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); 03499 } 03500 03501 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> 03502 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19> make_define_array(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) 03503 { 03504 return define_array<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); 03505 } 03506 03507 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> 03508 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20> make_define_array(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) 03509 { 03510 return define_array<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); 03511 } 03512 03513 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> 03514 inline define_array<A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21> make_define_array(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) 03515 { 03516 return define_array<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); 03517 } 03518 03519 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> 03520 inline define_array<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_array(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) 03521 { 03522 return define_array<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); 03523 } 03524 03525 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> 03526 inline define_array<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_array(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) 03527 { 03528 return define_array<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); 03529 } 03530 03531 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> 03532 inline define_array<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_array(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) 03533 { 03534 return define_array<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); 03535 } 03536 03537 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> 03538 inline define_array<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_array(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) 03539 { 03540 return define_array<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); 03541 } 03542 03543 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> 03544 inline define_array<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_array(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) 03545 { 03546 return define_array<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); 03547 } 03548 03549 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> 03550 inline define_array<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_array(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) 03551 { 03552 return define_array<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); 03553 } 03554 03555 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> 03556 inline define_array<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_array(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) 03557 { 03558 return define_array<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); 03559 } 03560 03561 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> 03562 inline define_array<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_array(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) 03563 { 03564 return define_array<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); 03565 } 03566 03567 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> 03568 inline define_array<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_array(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) 03569 { 03570 return define_array<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); 03571 } 03572 03573 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> 03574 inline define_array<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_array(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) 03575 { 03576 return define_array<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); 03577 } 03578 03579 /// @endcond 03580 03581 } // namespace type 03582 /// @cond 03583 } // MSGPACK_API_VERSION_NAMESPACE(v1) 03584 /// @endcond 03585 } // namespace msgpack 03586 03587 03588 #endif // MSGPACK_CPP03_DEFINE_ARRAY_HPP 03589
Generated on Tue Jul 12 2022 22:51:44 by
1.7.2