From c2ca709d686b758e9891984381a6bcb38a0baa23 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 22 Aug 2013 17:21:47 +0900 Subject: [PATCH 001/153] Added header files that use c++11 variadic templates instead of ruby code generation. When the compiler configured to support C++11 (e.g. CXXFLAG contains -std=c++11 is given), those files are used. Decoupled unpacker and msgpack_unpacker. This modification introduced C++11 dependency such as nullptr and unique_ptr. I will support C++11 and C++03, finally. Decoupled msgpack.hpp and msgpack.h. Decoupled sbuffer from msgpack_sbuffer. Decoupled vrefbuffer from msgpack_vrefbuffer. Decoupled zbuffer from msgpack_zbuffer. Added some z_stream initialization. Removed unpack macros. Removed CTX_CAST and CTX_REFERENCED. Embed ctx_ as a member variable (not a pointer). Modified zone free using C++ way. --- .gitignore | 1 + CMakeLists.txt | 36 ++ README.md | 20 + configure.in | 22 ++ cpp11/define.hpp | 170 +++++++++ cpp11/tuple.hpp | 125 +++++++ cpp11/zone.hpp | 304 ++++++++++++++++ preprocess_cpp11 | 17 + src/Makefile.am | 2 + src/msgpack.hpp | 2 +- src/msgpack/sbuffer.hpp | 65 ++-- src/msgpack/unpack.hpp | 729 +++++++++++++++++++++++++++++++++++-- src/msgpack/version.hpp.in | 37 ++ src/msgpack/vrefbuffer.hpp | 219 ++++++++++- src/msgpack/zbuffer.hpp | 102 ++++-- test/fixint_c.cc | 2 +- test/msgpack_test.cpp | 24 +- test/streaming.cc | 12 +- test/zone.cc | 6 +- 19 files changed, 1761 insertions(+), 134 deletions(-) create mode 100644 cpp11/define.hpp create mode 100644 cpp11/tuple.hpp create mode 100644 cpp11/zone.hpp create mode 100755 preprocess_cpp11 create mode 100644 src/msgpack/version.hpp.in diff --git a/.gitignore b/.gitignore index ffc26910..3328fdce 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,7 @@ Makefile.in /libtool /msgpack.pc /src/msgpack/version.h +/src/msgpack/version.hpp /stamp-h1 Makefile .deps diff --git a/CMakeLists.txt b/CMakeLists.txt index 4ee162dd..79c86ba2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,6 +10,18 @@ SET (exec_prefix "\${prefix}") SET (libdir "\${exec_prefix}/lib") SET (includedir "\${prefix}/include") +OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF) + +IF (MSGPACK_CXX11) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}") + ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + SET (CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}") + ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + MESSAGE ( FATAL_ERROR "MSVC doesn't support C++11 yet.") + ENDIF () +ENDIF () + FIND_PACKAGE (GTest) FIND_PACKAGE (ZLIB) FIND_PACKAGE (Threads) @@ -17,6 +29,26 @@ IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND) OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON) ENDIF () + +# Files to copy + +MACRO (COPY_FILE SOURCE DESTINATION) + # COPY_FILE (readme.txt dir1/dir2/) would add new target + # that will copy readme.txt to dir1/dir2 where dir1 will be located + # in current binary directory. + ADD_CUSTOM_COMMAND ( + OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DESTINATION}/${SOURCE} + COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${DESTINATION} + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE} ${CMAKE_CURRENT_BINARY_DIR}/${DESTINATION}/${SOURCE} + ) +ENDMACRO () + +IF (MSGPACK_CXX11) + COPY_FILE (cpp11/zone.hpp src/msgpack/zone.hpp) + COPY_FILE (cpp11/define.hpp src/msgpack/type/define.hpp) + COPY_FILE (cpp11/tuple.hpp src/msgpack/type/tuple.hpp) +ENDIF () + OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON) INCLUDE (CheckCXXSourceCompiles) @@ -109,6 +141,10 @@ CONFIGURE_FILE ( src/msgpack/version.h.in ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.h ) +CONFIGURE_FILE ( + src/msgpack/version.hpp.in + ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.hpp +) CONFIGURE_FILE ( msgpack.pc.in diff --git a/README.md b/README.md index 8799052a..a9621f1b 100644 --- a/README.md +++ b/README.md @@ -38,6 +38,16 @@ $ make $ sudo make install ``` +If you want to setup C++11 version of msgpack, execute the following command: + +``` +$ git clone https://github.com/msgpack/msgpack-c.git +$ cd msgpack-c +$ ./bootstrap +$ ./configure CXXFLAGS="-std=c++11" +``` +You need the compiler that fully supports C++11. + ##### Using cmake You will need gcc (4.1.0 or higher), cmake. @@ -48,6 +58,16 @@ $ cmake . $ make ``` +If you want to setup C++11 version of msgpack, execute the following command: + +``` +$ git clone https://github.com/msgpack/msgpack-c.git +$ cd msgpack-c +$ cmake -DMSGPACK_CXX11=ON . +``` + +You need the compiler that fully supports C++11. + #### Install from package ##### UNIX-like platform with ./configure diff --git a/configure.in b/configure.in index b22714a8..bb61f60d 100644 --- a/configure.in +++ b/configure.in @@ -3,6 +3,27 @@ AC_CONFIG_AUX_DIR(ac) AM_INIT_AUTOMAKE(msgpack, 0.5.9) AC_CONFIG_HEADER(config.h) + +AC_LANG_PUSH([C++]) +AC_COMPILE_IFELSE([AC_LANG_SOURCE([ +#if __cplusplus < 201103 +#error +#endif +])], +[ +./preprocess_cpp11 +if test $? != 0; then + exit 1 +fi +], +[ +./preprocess +if test $? != 0; then + exit 1 +fi +]) +AC_LANG_POP() + AC_SUBST(CFLAGS) CFLAGS="-O3 -Wall $CFLAGS" @@ -96,5 +117,6 @@ AC_OUTPUT([Makefile msgpack.pc src/Makefile src/msgpack/version.h + src/msgpack/version.hpp test/Makefile]) diff --git a/cpp11/define.hpp b/cpp11/define.hpp new file mode 100644 index 00000000..9754af27 --- /dev/null +++ b/cpp11/define.hpp @@ -0,0 +1,170 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_DEFINE_HPP +#define MSGPACK_TYPE_DEFINE_HPP + +#define MSGPACK_DEFINE(...) \ + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } + +// MSGPACK_ADD_ENUM must be used in the global namespace. +#define MSGPACK_ADD_ENUM(enum) \ + namespace msgpack { \ + template <> \ + inline enum& operator>> (object o, enum& v) \ + { \ + int tmp; \ + o >> tmp; \ + v = static_cast(tmp); \ + return v; \ + } \ + template <> \ + void operator<< (object::with_zone& o, const enum& v) \ + { \ + int tmp = static_cast(v); \ + o << tmp; \ + } \ + namespace detail { \ + template \ + struct packer_serializer { \ + static packer& pack(packer& o, const enum& v) { \ + return o << static_cast(v); \ + } \ + }; \ + } \ + } + +namespace msgpack { +namespace type { + +template +struct define_imp { + template + static void pack(Packer& pk, Tuple const& t) { + define_imp::pack(pk, t); + pk.pack(std::get(t)); + } + static void unpack(msgpack::object o, Tuple& t) { + define_imp::unpack(o, t); + const size_t size = o.via.array.size; + if(size <= N-1) { return; } + o.via.array.ptr[N-1].convert(&std::get(t)); + } + static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { + define_imp::object(o, z, t); + o->via.array.ptr[N-1] = msgpack::object(std::get(t), z); + } +}; + +template +struct define_imp { + template + static void pack(Packer& pk, Tuple const& t) { + pk.pack(std::get<0>(t)); + } + static void unpack(msgpack::object o, Tuple& t) { + const size_t size = o.via.array.size; + if(size <= 0) { return; } + o.via.array.ptr[0].convert(&std::get<0>(t)); + } + static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { + o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z); + } +}; + +template +struct define { + typedef define value_type; + typedef tuple tuple_type; + define(Args&... args) : + a(args...) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(sizeof...(Args)); + + define_imp, sizeof...(Args)>::pack(pk, a); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + + define_imp, sizeof...(Args)>::unpack(o, a); + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = (object*)z->malloc(sizeof(object)*sizeof...(Args)); + o->via.array.size = sizeof...(Args); + + define_imp, sizeof...(Args)>::object(o, z, a); + } + + tuple a; +}; + +template <> +struct define<> { + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = NULL; + o->via.array.size = 0; + } +}; + +inline define<> make_define() +{ + return define<>(); +} + +template +define make_define(Args&... args) +{ + return define(args...); +} + +} // namespace type +} // namespace msgpack + + +#endif /* msgpack/type/define.hpp */ + diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp new file mode 100644 index 00000000..0fb015a4 --- /dev/null +++ b/cpp11/tuple.hpp @@ -0,0 +1,125 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TUPLE_HPP +#define MSGPACK_TYPE_TUPLE_HPP + +#include "msgpack/object.hpp" +#include + +namespace msgpack { +namespace type { + +template +using tuple = std::tuple; + +} // type + +// --- Pack ( from tuple to packer stream --- +template +struct Packer { + static void pack( + packer& o, + const Tuple& v) { + Packer::pack(o, v); + o.pack(std::get(v)); + } +}; + +template +struct Packer { + static void pack ( + packer& o, + const Tuple& v) { + o.pack(std::get<0>(v)); + } +}; + +template +const packer& operator<< ( + packer& o, + const type::tuple& v) { + o.pack_array(sizeof...(Args)); + Packer::pack(o, v); + return o; +} + +// --- Convert from tuple to object --- + +template +struct Converter { + static void convert( + object o, + Tuple& v) { + Converter::convert(o, v); + o.via.array.ptr[N-1].convert(v))>::type>(&std::get(v)); + } +}; + +template +struct Converter { + static void convert ( + object o, + Tuple& v) { + o.via.array.ptr[0].convert(v))>::type>(&std::get<0>(v)); + } +}; + +template +type::tuple& operator>> ( + object o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw type_error(); } + Converter::convert(o, v); + return v; +} + +// --- Convert from tuple to object with zone --- +template +struct TupleToObjectWithZone { + static void convert( + object::with_zone& o, + const Tuple& v) { + TupleToObjectWithZone::convert(o, v); + o.via.array.ptr[N-1] = object(std::get(v), o.zone); + } +}; + +template +struct TupleToObjectWithZone { + static void convert ( + object::with_zone& o, + const Tuple& v) { + o.via.array.ptr[0] = object(std::get<0>(v), o.zone); + } +}; + +template +inline void operator<< ( + object::with_zone& o, + type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*sizeof...(Args)); + o.via.array.size = sizeof...(Args); + TupleToObjectWithZone::convert(o, v); +} + +} // msgpack + +#endif /* msgpack/type/tuple.hpp */ + diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp new file mode 100644 index 00000000..f15733ab --- /dev/null +++ b/cpp11/zone.hpp @@ -0,0 +1,304 @@ +// +// MessagePack for C++ memory pool +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_ZONE_HPP +#define MSGPACK_ZONE_HPP + +#include +#include +#include + +#ifndef MSGPACK_ZONE_CHUNK_SIZE +#define MSGPACK_ZONE_CHUNK_SIZE 8192 +#endif + +#ifndef MSGPACK_ZONE_ALIGN +#define MSGPACK_ZONE_ALIGN sizeof(int) +#endif + +namespace msgpack { + +class zone { +private: + struct finalizer { + finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} + void operator()() { func_(data_); } + void (*func_)(void*); + void* data_; + }; + struct finalizer_array { + finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} + void call() { + finalizer* fin = tail_; + for(; fin != array_; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(array_); + } + void clear() { + call(); + tail_ = array_; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = tail_; + + if(fin == end_) { + push_expand(func, data); + return; + } + + fin->func_ = func; + fin->data_ = data; + + ++tail_; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = end_ - array_; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + (finalizer*)::realloc(array_, sizeof(finalizer) * nnext); + if(!tmp) { + throw std::bad_alloc(); + } + array_ = tmp; + end_ = tmp + nnext; + tail_ = tmp + nused; + new (tail_) finalizer(func, data); + + ++tail_; + } + finalizer* tail_; + finalizer* end_; + finalizer* array_; + }; + struct chunk { + chunk* next_; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size); + if(!c) { + throw std::bad_alloc(); + } + + head_ = c; + free_ = chunk_size; + ptr_ = ((char*)c) + sizeof(chunk); + c->next_ = nullptr; + } + ~chunk_list() + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + ::free(c); + if(n) { + c = n; + } else { + break; + } + } + } + void clear(size_t chunk_size) + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + head_->next_ = nullptr; + free_ = chunk_size; + ptr_ = ((char*)head_) + sizeof(chunk); + } + size_t free_; + char* ptr_; + chunk* head_; + }; + size_t chunk_size_; + chunk_list chunk_list_; + finalizer_array finalizer_array_; + +public: + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); + +public: + static zone* create(size_t chunk_size); + static void destroy(zone* zone); + void* malloc(size_t size); + void* malloc_no_align(size_t size); + + void push_finalizer(void (*func)(void*), void* data); + + template + void push_finalizer(std::unique_ptr obj); + + void clear(); + + void swap(zone& o); + + + template + T* allocate(Args... args); + +private: + void undo_malloc(size_t size); + + template + static void object_destructor(void* obj); + + void* malloc_expand(size_t size); +}; + +inline zone* zone::create(size_t chunk_size) +{ + zone* z = (zone*)::malloc(sizeof(zone) + chunk_size); + if (!z) { + return nullptr; + } + try { + new (z) zone(chunk_size); + } + catch (...) { + ::free(z); + return nullptr; + } + return z; +} + +inline void zone::destroy(zone* z) +{ + z->~zone(); + ::free(z); +} + +inline zone::zone(size_t chunk_size):chunk_size_(chunk_size), chunk_list_(chunk_size_) +{ +} + +inline void* zone::malloc(size_t size) +{ + return malloc_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); +} + +inline void* zone::malloc_no_align(size_t size) +{ + if(chunk_list_.free_ < size) { + return malloc_expand(size); + } + + char* ptr = chunk_list_.ptr_; + chunk_list_.free_ -= size; + chunk_list_.ptr_ += size; + + return ptr; +} + +inline void* zone::malloc_expand(size_t size) +{ + chunk_list* const cl = &chunk_list_; + + size_t sz = chunk_size_; + + while(sz < size) { + sz *= 2; + } + + chunk* c = (chunk*)::malloc(sizeof(chunk) + sz); + + char* ptr = ((char*)c) + sizeof(chunk); + + c->next_ = cl->head_; + cl->head_ = c; + cl->free_ = sz - size; + cl->ptr_ = ptr + size; + + return ptr; +} + +inline void zone::push_finalizer(void (*func)(void*), void* data) +{ + finalizer_array_.push(func, data); +} + +template +inline void zone::push_finalizer(std::unique_ptr obj) +{ + finalizer_array_.push(&zone::object_destructor, obj.get()); + obj.release(); +} + +inline void zone::clear() +{ + finalizer_array_.clear(); + chunk_list_.clear(chunk_size_); +} + +inline void zone::swap(zone& o) +{ + std::swap(*this, o); +} + +template +void zone::object_destructor(void* obj) +{ + reinterpret_cast(obj)->~T(); +} + +inline void zone::undo_malloc(size_t size) +{ + chunk_list_.ptr_ -= size; + chunk_list_.free_ += size; +} + + +template +T* zone::allocate(Args... args) +{ + void* x = malloc(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_malloc(sizeof(T)); + throw; + } + try { + return new (x) T(args...); + } catch (...) { + --finalizer_array_.tail_; + undo_malloc(sizeof(T)); + throw; + } +} + +} // namespace msgpack + +#endif /* msgpack/zone.hpp */ diff --git a/preprocess_cpp11 b/preprocess_cpp11 new file mode 100755 index 00000000..d7b01d33 --- /dev/null +++ b/preprocess_cpp11 @@ -0,0 +1,17 @@ +#!/bin/sh + +if [ "$1" = "clean" ];then + rm -f src/msgpack/type/tuple.hpp + rm -f src/msgpack/type/define.hpp + rm -f src/msgpack/zone.hpp +else + cp -f cpp11/zone.hpp src/msgpack/ + cp -f cpp11/tuple.hpp src/msgpack/type/ + cp -f cpp11/define.hpp src/msgpack/type/ +fi +cp -f cases.mpac test/ +cp -f cases_compact.mpac test/ + +sed -e 's/8\.00/9.00/' < msgpack_vc8.vcproj > msgpack_vc2008.vcproj +sed -e 's/9\.00/10.00/' -e 's/msgpack_vc8/msgpack_vc2008/' < msgpack_vc8.sln > msgpack_vc2008.sln + diff --git a/src/Makefile.am b/src/Makefile.am index 37993f26..93207b8c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -62,6 +62,7 @@ nobase_include_HEADERS += \ msgpack/fbuffer.hpp \ msgpack/pack.hpp \ msgpack/unpack.hpp \ + msgpack/version.hpp \ msgpack/object.hpp \ msgpack/zone.hpp \ msgpack/type.hpp \ @@ -86,6 +87,7 @@ endif EXTRA_DIST = \ msgpack/version.h.in \ + msgpack/version.hpp.in \ msgpack/zone.hpp.erb \ msgpack/type/define.hpp.erb \ msgpack/type/tuple.hpp.erb diff --git a/src/msgpack.hpp b/src/msgpack.hpp index e14680dd..62d4b3d3 100644 --- a/src/msgpack.hpp +++ b/src/msgpack.hpp @@ -21,4 +21,4 @@ #include "msgpack/unpack.hpp" #include "msgpack/sbuffer.hpp" #include "msgpack/vrefbuffer.hpp" -#include "msgpack.h" +#include "msgpack/version.hpp" diff --git a/src/msgpack/sbuffer.hpp b/src/msgpack/sbuffer.hpp index fce56ad5..aa197038 100644 --- a/src/msgpack/sbuffer.hpp +++ b/src/msgpack/sbuffer.hpp @@ -1,7 +1,7 @@ // // MessagePack for C++ simple buffer implementation // -// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -15,94 +15,99 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_SBUFFER_HPP__ -#define MSGPACK_SBUFFER_HPP__ +#ifndef MSGPACK_SBUFFER_HPP +#define MSGPACK_SBUFFER_HPP -#include "sbuffer.h" #include +#ifndef MSGPACK_SBUFFER_INIT_SIZE +#define MSGPACK_SBUFFER_INIT_SIZE 8192 +#endif + namespace msgpack { -class sbuffer : public msgpack_sbuffer { +class sbuffer { public: - sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE) + sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):size_(0), alloc_(initsz) { if(initsz == 0) { - base::data = NULL; + data_ = nullptr; } else { - base::data = (char*)::malloc(initsz); - if(!base::data) { + data_ = (char*)::malloc(initsz); + if(!data_) { throw std::bad_alloc(); } } - - base::size = 0; - base::alloc = initsz; } ~sbuffer() { - ::free(base::data); + ::free(data_); } public: void write(const char* buf, size_t len) { - if(base::alloc - base::size < len) { + if(alloc_ - size_ < len) { expand_buffer(len); } - memcpy(base::data + base::size, buf, len); - base::size += len; + ::memcpy(data_ + size_, buf, len); + size_ += len; } char* data() { - return base::data; + return data_; } const char* data() const { - return base::data; + return data_; } size_t size() const { - return base::size; + return size_; } char* release() { - return msgpack_sbuffer_release(this); + char* tmp = data_; + size_ = 0; + data_ = nullptr; + alloc_ = 0; + return tmp; } void clear() { - msgpack_sbuffer_clear(this); + size_ = 0; } private: void expand_buffer(size_t len) { - size_t nsize = (base::alloc > 0) ? - base::alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; + size_t nsize = (alloc_ > 0) ? + alloc_ * 2 : MSGPACK_SBUFFER_INIT_SIZE; - while(nsize < base::size + len) { nsize *= 2; } + while(nsize < size_ + len) { nsize *= 2; } - void* tmp = realloc(base::data, nsize); + void* tmp = ::realloc(data_, nsize); if(!tmp) { throw std::bad_alloc(); } - base::data = (char*)tmp; - base::alloc = nsize; + data_ = (char*)tmp; + alloc_ = nsize; } -private: - typedef msgpack_sbuffer base; - private: sbuffer(const sbuffer&); +private: + size_t size_; + char* data_; + size_t alloc_; }; diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index baca1176..2b7c0b17 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -1,7 +1,7 @@ // // MessagePack for C++ deserializing routine // -// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -15,22 +15,490 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_UNPACK_HPP__ -#define MSGPACK_UNPACK_HPP__ +#ifndef MSGPACK_UNPACK_HPP +#define MSGPACK_UNPACK_HPP -#include "unpack.h" #include "object.hpp" #include "zone.hpp" +#include "unpack_define.h" + #include #include + +#define COUNTER_SIZE (sizeof(_msgpack_atomic_counter_t)) + +#ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE +#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024) +#endif + +#ifndef MSGPACK_UNPACKER_RESERVE_SIZE +#define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024) +#endif + + // backward compatibility #ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE #define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE #endif + namespace msgpack { +namespace detail { + +struct unpack_user { + zone* z; + bool referenced; +}; + + +static inline ::msgpack::object template_callback_root(unpack_user* u) +{ ::msgpack::object o = {}; return o; } + +static inline int template_callback_uint8(unpack_user* u, uint8_t d, ::msgpack::object* o) +{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + +static inline int template_callback_uint16(unpack_user* u, uint16_t d, ::msgpack::object* o) +{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + +static inline int template_callback_uint32(unpack_user* u, uint32_t d, ::msgpack::object* o) +{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + +static inline int template_callback_uint64(unpack_user* u, uint64_t d, ::msgpack::object* o) +{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + +static inline int template_callback_int8(unpack_user* u, int8_t d, ::msgpack::object* o) +{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + +static inline int template_callback_int16(unpack_user* u, int16_t d, ::msgpack::object* o) +{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + +static inline int template_callback_int32(unpack_user* u, int32_t d, ::msgpack::object* o) +{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + +static inline int template_callback_int64(unpack_user* u, int64_t d, ::msgpack::object* o) +{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + +static inline int template_callback_float(unpack_user* u, float d, ::msgpack::object* o) +{ o->type = ::msgpack::type::DOUBLE; o->via.dec = d; return 0; } + +static inline int template_callback_double(unpack_user* u, double d, ::msgpack::object* o) +{ o->type = ::msgpack::type::DOUBLE; o->via.dec = d; return 0; } + +static inline int template_callback_nil(unpack_user* u, ::msgpack::object* o) +{ o->type = ::msgpack::type::NIL; return 0; } + +static inline int template_callback_true(unpack_user* u, ::msgpack::object* o) +{ o->type = ::msgpack::type::BOOLEAN; o->via.boolean = true; return 0; } + +static inline int template_callback_false(unpack_user* u, ::msgpack::object* o) +{ o->type = ::msgpack::type::BOOLEAN; o->via.boolean = false; return 0; } + +static inline int template_callback_array(unpack_user* u, unsigned int n, ::msgpack::object* o) +{ + o->type = ::msgpack::type::ARRAY; + o->via.array.size = 0; + o->via.array.ptr = (::msgpack::object*)u->z->malloc(n*sizeof(::msgpack::object)); + if(o->via.array.ptr == NULL) { return -1; } + return 0; +} + +static inline int template_callback_array_item(unpack_user* u, ::msgpack::object* c, ::msgpack::object o) +{ c->via.array.ptr[c->via.array.size++] = o; return 0; } + +static inline int template_callback_map(unpack_user* u, unsigned int n, ::msgpack::object* o) +{ + o->type = ::msgpack::type::MAP; + o->via.map.size = 0; + o->via.map.ptr = (::msgpack::object_kv*)u->z->malloc(n*sizeof(::msgpack::object_kv)); + if(o->via.map.ptr == NULL) { return -1; } + return 0; +} + +static inline int template_callback_map_item(unpack_user* u, ::msgpack::object* c, ::msgpack::object k, ::msgpack::object v) +{ + c->via.map.ptr[c->via.map.size].key = k; + c->via.map.ptr[c->via.map.size].val = v; + ++c->via.map.size; + return 0; +} + +static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, ::msgpack::object* o) +{ + o->type = ::msgpack::type::RAW; + o->via.raw.ptr = p; + o->via.raw.size = l; + u->referenced = true; + return 0; +} + + +struct template_unpack_stack { + ::msgpack::object obj; + size_t count; + unsigned int ct; + ::msgpack::object map_key; +}; + +struct template_context { + unpack_user user; + unsigned int cs; + unsigned int trail; + unsigned int top; + template_unpack_stack stack[MSGPACK_EMBED_STACK_SIZE]; +}; + + +inline void init_count(void* buffer) +{ + *(volatile _msgpack_atomic_counter_t*)buffer = 1; +} + +inline void decl_count(void* buffer) +{ + // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); } + if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) { + free(buffer); + } +} + +inline void incr_count(void* buffer) +{ + // atomic ++*(_msgpack_atomic_counter_t*)buffer; + _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer); +} + +inline _msgpack_atomic_counter_t get_count(void* buffer) +{ + return *(volatile _msgpack_atomic_counter_t*)buffer; +} + +inline void template_init(template_context& ctx) +{ + ctx.cs = CS_HEADER; + ctx.trail = 0; + ctx.top = 0; + ctx.stack[0].obj = template_callback_root(&ctx.user); +} + +::msgpack::object template_data(template_context const& ctx) +{ + return ctx.stack[0].obj; +} + +template +inline unsigned int next_cs(T p) +{ + return (unsigned int)*p & 0x1f; +} + +int template_execute(template_context& ctx, const char* data, size_t len, size_t* off) +{ + assert(len >= *off); + + const unsigned char* p = (unsigned char*)data + *off; + const unsigned char* const pe = (unsigned char*)data + len; + const void* n = nullptr; + + unsigned int trail = ctx.trail; + unsigned int cs = ctx.cs; + unsigned int top = ctx.top; + detail::template_unpack_stack* stack = ctx.stack; + /* + unsigned int stack_size = ctx.stack_size; + */ + unpack_user* user = &ctx.user; + + ::msgpack::object obj; + detail::template_unpack_stack* c = nullptr; + + int ret; + + + if(p == pe) { goto _out; } + do { + switch(cs) { + case CS_HEADER: + if (0) { + } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum + if(template_callback_uint8(user, *(uint8_t*)p, &obj) < 0) { goto _failed; } + goto _push; + } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum + if(template_callback_int8(user, *(int8_t*)p, &obj) < 0) { goto _failed; } + goto _push; + } else if(0xc0 <= *p && *p <= 0xdf) { // Variable + switch(*p) { + case 0xc0: // nil + if(template_callback_nil(user, &obj) < 0) { goto _failed; } + goto _push; + //case 0xc1: // string + // again_terminal_trail(next_cs(p), p+1); + case 0xc2: // false + if(template_callback_false(user, &obj) < 0) { goto _failed; } + goto _push; + case 0xc3: // true + if(template_callback_true(user, &obj) < 0) { goto _failed; } + goto _push; + case 0xc4: // bin 8 + case 0xc5: // bin 16 + case 0xc6: // bin 32 + trail = 1 << (((unsigned int)*p) & 0x03); + cs = next_cs(p); + goto _fixed_trail_again; + + //case 0xc7: + //case 0xc8: + //case 0xc9: + case 0xca: // float + case 0xcb: // double + case 0xcc: // unsigned int 8 + case 0xcd: // unsigned int 16 + case 0xce: // unsigned int 32 + case 0xcf: // unsigned int 64 + case 0xd0: // signed int 8 + case 0xd1: // signed int 16 + case 0xd2: // signed int 32 + case 0xd3: // signed int 64 + trail = 1 << (((unsigned int)*p) & 0x03); + cs = next_cs(p); + goto _fixed_trail_again; + //case 0xd4: + //case 0xd5: + //case 0xd6: // big integer 16 + //case 0xd7: // big integer 32 + //case 0xd8: // big float 16 + case 0xd9: // raw 8 (str 8) + case 0xda: // raw 16 (str 16) + case 0xdb: // raw 32 (str 32) + trail = 1 << ((((unsigned int)*p) & 0x03) - 1); + cs = next_cs(p); + goto _fixed_trail_again; + case 0xdc: // array 16 + case 0xdd: // array 32 + case 0xde: // map 16 + case 0xdf: // map 32 + trail = 2 << (((unsigned int)*p) & 0x01); + cs = next_cs(p); + goto _fixed_trail_again; + default: + goto _failed; + } + } else if(0xa0 <= *p && *p <= 0xbf) { // FixRaw + trail = (unsigned int)*p & 0x1f; + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; + goto _fixed_trail_again; + + } else if(0x90 <= *p && *p <= 0x9f) { // FixArray + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_array(user, ((unsigned int)*p) & 0x0f, &stack[top].obj) < 0) { goto _failed; } + if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj; goto _push; } + stack[top].ct = CT_ARRAY_ITEM; + stack[top].count = ((unsigned int)*p) & 0x0f; + ++top; + goto _header_again; + + } else if(0x80 <= *p && *p <= 0x8f) { // FixMap + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_map(user, ((unsigned int)*p) & 0x0f, &stack[top].obj) < 0) { goto _failed; } + if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj; goto _push; } + stack[top].ct = CT_MAP_KEY; + stack[top].count = ((unsigned int)*p) & 0x0f; + ++top; + goto _header_again; + + } else { + goto _failed; + } + // end CS_HEADER + + + _fixed_trail_again: + ++p; + + default: + if((size_t)(pe - p) < trail) { goto _out; } + n = p; p += trail - 1; + switch(cs) { + //case CS_ + //case CS_ + case CS_FLOAT: { + union { uint32_t i; float f; } mem; + mem.i = _msgpack_load32(uint32_t,n); + if(template_callback_float(user, mem.f, &obj) < 0) { goto _failed; } + goto _push; } + case CS_DOUBLE: { + union { uint64_t i; double f; } mem; + mem.i = _msgpack_load64(uint64_t,n); +#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); +#endif + if(template_callback_double(user, mem.f, &obj) < 0) { goto _failed; } + goto _push; } + case CS_UINT_8: + if(template_callback_uint8(user, *(uint8_t*)n, &obj) < 0) { goto _failed; } + goto _push; + case CS_UINT_16: + if(template_callback_uint16(user, _msgpack_load16(uint16_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_UINT_32: + if(template_callback_uint32(user, _msgpack_load32(uint32_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_UINT_64: + if(template_callback_uint64(user, _msgpack_load64(uint64_t,n), &obj) < 0) { goto _failed; } + goto _push; + + case CS_INT_8: + if(template_callback_int8(user, *(int8_t*)n, &obj) < 0) { goto _failed; } + goto _push; + case CS_INT_16: + if(template_callback_int16(user, _msgpack_load16(int16_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_INT_32: + if(template_callback_int32(user, _msgpack_load32(int32_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_INT_64: + if(template_callback_int64(user, _msgpack_load64(int64_t,n), &obj) < 0) { goto _failed; } + goto _push; + + case CS_BIN_8: + case CS_RAW_8: + trail = *(uint8_t*)n; + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; + goto _fixed_trail_again; + case CS_BIN_16: + case CS_RAW_16: + trail = _msgpack_load16(uint16_t, n); + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; + goto _fixed_trail_again; + case CS_BIN_32: + case CS_RAW_32: + trail = _msgpack_load32(uint32_t, n); + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; + goto _fixed_trail_again; + case ACS_RAW_VALUE: + _raw_zero: + if(template_callback_raw(user, (const char*)data, (const char*)n, trail, &obj) < 0) { goto _failed; } + goto _push; + case CS_ARRAY_16: + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_array(user, _msgpack_load16(uint16_t, n), &stack[top].obj) < 0) { goto _failed; } + if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj; goto _push; } + stack[top].ct = CT_ARRAY_ITEM; + stack[top].count = _msgpack_load16(uint16_t, n); + ++top; + goto _header_again; + case CS_ARRAY_32: + /* FIXME security guard */ + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_array(user, _msgpack_load32(uint32_t, n), &stack[top].obj) < 0) { goto _failed; } + if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj; goto _push; } + stack[top].ct = CT_ARRAY_ITEM; + stack[top].count = _msgpack_load32(uint32_t, n); + ++top; + goto _header_again; + + case CS_MAP_16: + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_map(user, _msgpack_load16(uint16_t, n), &stack[top].obj) < 0) { goto _failed; } + if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj; goto _push; } + stack[top].ct = CT_MAP_KEY; + stack[top].count = _msgpack_load16(uint16_t, n); + ++top; + goto _header_again; + case CS_MAP_32: + /* FIXME security guard */ + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_map(user, _msgpack_load32(uint32_t, n), &stack[top].obj) < 0) { goto _failed; } + if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj; goto _push; } + stack[top].ct = CT_MAP_KEY; + stack[top].count = _msgpack_load32(uint32_t, n); + ++top; + goto _header_again; + + default: + goto _failed; + } + } + +_push: + if(top == 0) { goto _finish; } + c = &stack[top-1]; + switch(c->ct) { + case CT_ARRAY_ITEM: + if(template_callback_array_item(user, &c->obj, obj) < 0) { goto _failed; } + if(--c->count == 0) { + obj = c->obj; + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } + goto _header_again; + case CT_MAP_KEY: + c->map_key = obj; + c->ct = CT_MAP_VALUE; + goto _header_again; + case CT_MAP_VALUE: + if(template_callback_map_item(user, &c->obj, c->map_key, obj) < 0) { goto _failed; } + if(--c->count == 0) { + obj = c->obj; + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } + c->ct = CT_MAP_KEY; + goto _header_again; + + default: + goto _failed; + } + +_header_again: + cs = CS_HEADER; + ++p; + } while(p != pe); + goto _out; + + +_finish: + stack[0].obj = obj; + ++p; + ret = 1; + /*printf("-- finish --\n"); */ + goto _end; + +_failed: + /*printf("** FAILED **\n"); */ + ret = -1; + goto _end; + +_out: + ret = 0; + goto _end; + +_end: + ctx.cs = cs; + ctx.trail = trail; + ctx.top = top; + *off = p - (const unsigned char*)data; + + return ret; +} + + + + +} // detail + struct unpack_error : public std::runtime_error { unpack_error(const std::string& msg) : @@ -42,8 +510,8 @@ class unpacked { public: unpacked() { } - unpacked(object obj, std::auto_ptr z) : - m_obj(obj), m_zone(z) { } + unpacked(object obj, std::unique_ptr z) : + m_obj(obj), m_zone(std::move(z)) { } object& get() { return m_obj; } @@ -51,19 +519,19 @@ public: const object& get() const { return m_obj; } - std::auto_ptr& zone() + std::unique_ptr& zone() { return m_zone; } - const std::auto_ptr& zone() const + const std::unique_ptr& zone() const { return m_zone; } private: object m_obj; - std::auto_ptr m_zone; + std::unique_ptr m_zone; }; -class unpacker : public msgpack_unpacker { +class unpacker { public: unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); ~unpacker(); @@ -154,7 +622,19 @@ public: void remove_nonparsed_buffer(); private: - typedef msgpack_unpacker base; + void expand_buffer(size_t size); + int execute_imp(); + bool flush_zone(); + +private: + char* buffer_; + size_t used_; + size_t free_; + size_t off_; + size_t parsed_; + zone* z_; + size_t initial_buffer_size_; + detail::template_context ctx_; private: unpacker(const unpacker&); @@ -184,42 +664,130 @@ static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL); inline unpacker::unpacker(size_t initial_buffer_size) { - if(!msgpack_unpacker_init(this, initial_buffer_size)) { + if(initial_buffer_size < COUNTER_SIZE) { + initial_buffer_size = COUNTER_SIZE; + } + + char* buffer = (char*)::malloc(initial_buffer_size); + if(!buffer) { throw std::bad_alloc(); } + + zone* z = zone::create(MSGPACK_ZONE_CHUNK_SIZE); + if(!z) { + ::free(buffer); + throw std::bad_alloc(); + } + + buffer_ = buffer; + used_ = COUNTER_SIZE; + free_ = initial_buffer_size - used_; + off_ = COUNTER_SIZE; + parsed_ = 0; + initial_buffer_size_ = initial_buffer_size; + z_ = z; + + detail::init_count(buffer_); + + detail::template_init(ctx_); + ctx_.user.z = z_; + ctx_.user.referenced = false; } inline unpacker::~unpacker() { - msgpack_unpacker_destroy(this); + zone::destroy(z_); + detail::decl_count(buffer_); } inline void unpacker::reserve_buffer(size_t size) { - if(!msgpack_unpacker_reserve_buffer(this, size)) { - throw std::bad_alloc(); + if(free_ >= size) return; + expand_buffer(size); +} + +inline void unpacker::expand_buffer(size_t size) +{ + if(used_ == off_ && detail::get_count(buffer_) == 1 + && !ctx_.user.referenced) { + // rewind buffer + free_ += used_ - COUNTER_SIZE; + used_ = COUNTER_SIZE; + off_ = COUNTER_SIZE; + + if(free_ >= size) return; + } + + if(off_ == COUNTER_SIZE) { + size_t next_size = (used_ + free_) * 2; // include COUNTER_SIZE + while(next_size < size + used_) { + next_size *= 2; + } + + char* tmp = (char*)::realloc(buffer_, next_size); + if(!tmp) { + throw std::bad_alloc(); + } + + buffer_ = tmp; + free_ = next_size - used_; + + } else { + size_t next_size = initial_buffer_size_; // include COUNTER_SIZE + size_t not_parsed = used_ - off_; + while(next_size < size + not_parsed + COUNTER_SIZE) { + next_size *= 2; + } + + char* tmp = (char*)::malloc(next_size); + if(!tmp) { + throw std::bad_alloc(); + } + + detail::init_count(tmp); + + ::memcpy(tmp+COUNTER_SIZE, buffer_ + off_, not_parsed); + + if(ctx_.user.referenced) { + try { + z_->push_finalizer(&detail::decl_count, buffer_); + } + catch (...) { + ::free(tmp); + throw; + } + ctx_.user.referenced = false; + } else { + detail::decl_count(buffer_); + } + + buffer_ = tmp; + used_ = not_parsed + COUNTER_SIZE; + free_ = next_size - used_; + off_ = COUNTER_SIZE; } } inline char* unpacker::buffer() { - return msgpack_unpacker_buffer(this); + return buffer_ + used_; } inline size_t unpacker::buffer_capacity() const { - return msgpack_unpacker_buffer_capacity(this); + return free_; } inline void unpacker::buffer_consumed(size_t size) { - return msgpack_unpacker_buffer_consumed(this, size); + used_ += size; + free_ -= size; } inline bool unpacker::next(unpacked* result) { - int ret = msgpack_unpacker_execute(this); + int ret = execute_imp(); if(ret < 0) { throw unpack_error("parse error"); @@ -241,7 +809,7 @@ inline bool unpacker::next(unpacked* result) inline bool unpacker::execute() { - int ret = msgpack_unpacker_execute(this); + int ret = execute_imp(); if(ret < 0) { throw unpack_error("parse error"); } else if(ret == 0) { @@ -251,77 +819,159 @@ inline bool unpacker::execute() } } +inline int unpacker::execute_imp() +{ + size_t off = off_; + int ret = detail::template_execute(ctx_, + buffer_, used_, &off_); + if(off_ > off) { + parsed_ += off_ - off; + } + return ret; +} + inline object unpacker::data() { - return msgpack_unpacker_data(this); + return template_data(ctx_); } inline zone* unpacker::release_zone() { - return static_cast(msgpack_unpacker_release_zone(static_cast(this))); + if(!flush_zone()) { + return nullptr; + } + + zone* r = zone::create(MSGPACK_ZONE_CHUNK_SIZE); + if(!r) { + return nullptr; + } + + zone* old = z_; + z_ = r; + ctx_.user.z = z_; + + return old; } inline void unpacker::reset_zone() { - msgpack_unpacker_reset_zone(this); + z_->clear(); +} + +inline bool unpacker::flush_zone() +{ + if(ctx_.user.referenced) { + try { + z_->push_finalizer(&detail::decl_count, buffer_); + } catch (...) { + return false; + } + ctx_.user.referenced = false; + + detail::incr_count(buffer_); + } + + return true; } inline void unpacker::reset() { - msgpack_unpacker_reset(this); + detail::template_init(ctx_); + // don't reset referenced flag + parsed_ = 0; } - inline size_t unpacker::message_size() const { - return msgpack_unpacker_message_size(this); + return parsed_ - off_ + used_; } inline size_t unpacker::parsed_size() const { - return msgpack_unpacker_parsed_size(this); + return parsed_; } inline char* unpacker::nonparsed_buffer() { - return base::buffer + base::off; + return buffer_ + off_; } inline size_t unpacker::nonparsed_size() const { - return base::used - base::off; + return used_ - off_; } inline void unpacker::skip_nonparsed_buffer(size_t size) { - base::off += size; + off_ += size; } inline void unpacker::remove_nonparsed_buffer() { - base::used = base::off; + used_ = off_; } +namespace detail { + +inline unpack_return +unpack_imp(const char* data, size_t len, size_t* off, + zone* result_zone, ::msgpack::object* result) +{ + size_t noff = 0; + if(off != NULL) { noff = *off; } + + if(len <= noff) { + // FIXME + return UNPACK_CONTINUE; + } + + detail::template_context ctx; + detail::template_init(ctx); + + ctx.user.z = result_zone; + ctx.user.referenced = false; + + int e = detail::template_execute(ctx, data, len, &noff); + if(e < 0) { + return UNPACK_PARSE_ERROR; + } + + if(off != NULL) { *off = noff; } + + if(e == 0) { + return UNPACK_CONTINUE; + } + + *result = detail::template_data(ctx); + + if(noff < len) { + return UNPACK_EXTRA_BYTES; + } + + return UNPACK_SUCCESS; +} + +} // detail inline void unpack(unpacked* result, const char* data, size_t len, size_t* offset) { msgpack::object obj; - std::auto_ptr z(new zone()); + std::unique_ptr z(new zone()); + + unpack_return ret = detail::unpack_imp( + data, len, offset, z.get(), &obj); - unpack_return ret = (unpack_return)msgpack_unpack( - data, len, offset, z.get(), - reinterpret_cast(&obj)); switch(ret) { case UNPACK_SUCCESS: result->get() = obj; - result->zone() = z; + result->zone() = std::move(z); return; case UNPACK_EXTRA_BYTES: result->get() = obj; - result->zone() = z; + result->zone() = std::move(z); return; case UNPACK_CONTINUE: @@ -338,8 +988,8 @@ inline void unpack(unpacked* result, inline unpack_return unpack(const char* data, size_t len, size_t* off, zone* z, object* result) { - return (unpack_return)msgpack_unpack(data, len, off, - z, reinterpret_cast(result)); + return detail::unpack_imp(data, len, off, + z, result); } // obsolete @@ -367,7 +1017,6 @@ inline object unpack(const char* data, size_t len, zone& z, size_t* off) } } - } // namespace msgpack #endif /* msgpack/unpack.hpp */ diff --git a/src/msgpack/version.hpp.in b/src/msgpack/version.hpp.in new file mode 100644 index 00000000..f13ab0b7 --- /dev/null +++ b/src/msgpack/version.hpp.in @@ -0,0 +1,37 @@ +/* + * MessagePack for C++ version information + * + * Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_VERSION_HPP +#define MSGPACK_VERSION_HPP + +#define MSGPACK_VERSION "@VERSION@" +#define MSGPACK_VERSION_MAJOR @VERSION_MAJOR@ +#define MSGPACK_VERSION_MINOR @VERSION_MINOR@ + +inline const char* msgpack_version(void) { + return MSGPACK_VERSION; +} + +inline int msgpack_version_major(void) { + return MSGPACK_VERSION_MAJOR; +} + +inline int msgpack_version_minor(void) { + return MSGPACK_VERSION_MINOR; +} + +#endif /* msgpack/version.hpp */ diff --git a/src/msgpack/vrefbuffer.hpp b/src/msgpack/vrefbuffer.hpp index 2cf7f89c..8d22cfea 100644 --- a/src/msgpack/vrefbuffer.hpp +++ b/src/msgpack/vrefbuffer.hpp @@ -1,7 +1,7 @@ // // MessagePack for C++ zero-copy buffer implementation // -// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -15,34 +15,96 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_VREFBUFFER_HPP__ -#define MSGPACK_VREFBUFFER_HPP__ +#ifndef MSGPACK_VREFBUFFER_HPP +#define MSGPACK_VREFBUFFER_HPP -#include "vrefbuffer.h" #include +#ifndef MSGPACK_VREFBUFFER_REF_SIZE +#define MSGPACK_VREFBUFFER_REF_SIZE 32 +#endif + +#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE +#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192 +#endif + +#ifndef _WIN32 +#include +#else +struct iovec { + void *iov_base; + size_t iov_len; +}; +#endif + namespace msgpack { +namespace detail { -class vrefbuffer : public msgpack_vrefbuffer { + +} // detail + +class vrefbuffer { +private: + struct chunk { + chunk* next; + }; + struct inner_buffer { + size_t free; + char* ptr; + chunk* head; + }; public: vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) + :ref_size_(ref_size), chunk_size_(chunk_size) { - if (!msgpack_vrefbuffer_init(this, ref_size, chunk_size)) { + size_t nfirst = (sizeof(iovec) < 72/2) ? + 72 / sizeof(iovec) : 8; + + iovec* array = (iovec*)::malloc( + sizeof(iovec) * nfirst); + if(!array) { throw std::bad_alloc(); } + + tail_ = array; + end_ = array + nfirst; + array_ = array; + + chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size); + if(!c) { + ::free(array); + throw std::bad_alloc(); + } + inner_buffer* const ib = &inner_buffer_; + + ib->free = chunk_size; + ib->ptr = ((char*)c) + sizeof(chunk); + ib->head = c; + c->next = nullptr; + } ~vrefbuffer() { - msgpack_vrefbuffer_destroy(this); + chunk* c = inner_buffer_.head; + while(true) { + chunk* n = c->next; + ::free(c); + if(n != NULL) { + c = n; + } else { + break; + } + } + ::free(array_); } public: void write(const char* buf, size_t len) { - if(len < base::ref_size) { + if(len < ref_size_) { append_copy(buf, len); } else { append_ref(buf, len); @@ -51,45 +113,162 @@ public: void append_ref(const char* buf, size_t len) { - if(msgpack_vrefbuffer_append_ref(this, buf, len) < 0) { - throw std::bad_alloc(); + if(tail_ == end_) { + const size_t nused = tail_ - array_; + const size_t nnext = nused * 2; + + iovec* nvec = (iovec*)::realloc( + array_, sizeof(iovec)*nnext); + if(!nvec) { + throw std::bad_alloc(); + } + + array_ = nvec; + end_ = nvec + nnext; + tail_ = nvec + nused; } + + tail_->iov_base = (char*)buf; + tail_->iov_len = len; + ++tail_; } void append_copy(const char* buf, size_t len) { - if(msgpack_vrefbuffer_append_copy(this, buf, len) < 0) { - throw std::bad_alloc(); + inner_buffer* const ib = &inner_buffer_; + + if(ib->free < len) { + size_t sz = chunk_size_; + if(sz < len) { + sz = len; + } + + chunk* c = (chunk*)::malloc(sizeof(chunk) + sz); + if(!c) { + throw std::bad_alloc(); + } + + c->next = ib->head; + ib->head = c; + ib->free = sz; + ib->ptr = ((char*)c) + sizeof(chunk); + } + + char* m = ib->ptr; + ::memcpy(m, buf, len); + ib->free -= len; + ib->ptr += len; + + if(tail_ != array_ && m == + (const char*)((tail_ - 1)->iov_base) + (tail_ - 1)->iov_len) { + (tail_ - 1)->iov_len += len; + return; + } else { + append_ref( m, len); } } const struct iovec* vector() const { - return msgpack_vrefbuffer_vec(this); + return array_; } size_t vector_size() const { - return msgpack_vrefbuffer_veclen(this); + return tail_ - array_; } void migrate(vrefbuffer* to) { - if(msgpack_vrefbuffer_migrate(this, to) < 0) { + size_t sz = chunk_size_; + + chunk* empty = (chunk*)::malloc(sizeof(chunk) + sz); + if(!empty) { throw std::bad_alloc(); } - } + empty->next = nullptr; + + const size_t nused = tail_ - array_; + if(to->tail_ + nused < end_) { + const size_t tosize = to->tail_ - to->array_; + const size_t reqsize = nused + tosize; + size_t nnext = (to->end_ - to->array_) * 2; + while(nnext < reqsize) { + nnext *= 2; + } + + iovec* nvec = (iovec*)::realloc( + to->array_, sizeof(iovec)*nnext); + if(!nvec) { + ::free(empty); + throw std::bad_alloc(); + } + + to->array_ = nvec; + to->end_ = nvec + nnext; + to->tail_ = nvec + tosize; + } + + ::memcpy(to->tail_, array_, sizeof(iovec)*nused); + + to->tail_ += nused; + tail_ = array_; + + + inner_buffer* const ib = &inner_buffer_; + inner_buffer* const toib = &to->inner_buffer_; + + chunk* last = ib->head; + while(last->next) { + last = last->next; + } + last->next = toib->head; + toib->head = ib->head; + + if(toib->free < ib->free) { + toib->free = ib->free; + toib->ptr = ib->ptr; + } + + ib->head = empty; + ib->free = sz; + ib->ptr = ((char*)empty) + sizeof(chunk); + + } + void clear() { - msgpack_vrefbuffer_clear(this); - } + chunk* c = inner_buffer_.head->next; + chunk* n; + while(c) { + n = c->next; + ::free(c); + c = n; + } -private: - typedef msgpack_vrefbuffer base; + inner_buffer* const ib = &inner_buffer_; + c = ib->head; + c->next = nullptr; + ib->free = chunk_size_; + ib->ptr = ((char*)c) + sizeof(chunk); + + tail_ = array_; + } private: vrefbuffer(const vrefbuffer&); + +private: + iovec* tail_; + iovec* end_; + iovec* array_; + + size_t ref_size_; + size_t chunk_size_; + + inner_buffer inner_buffer_; + }; diff --git a/src/msgpack/zbuffer.hpp b/src/msgpack/zbuffer.hpp index 69e2eb79..1afe8025 100644 --- a/src/msgpack/zbuffer.hpp +++ b/src/msgpack/zbuffer.hpp @@ -1,7 +1,7 @@ // // MessagePack for C++ deflate buffer implementation // -// Copyright (C) 2010 FURUHASHI Sadayuki +// Copyright (C) 2010-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -15,84 +15,144 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_ZBUFFER_HPP__ -#define MSGPACK_ZBUFFER_HPP__ +#ifndef MSGPACK_ZBUFFER_HPP +#define MSGPACK_ZBUFFER_HPP -#include "zbuffer.h" #include +#include + +#ifndef MSGPACK_ZBUFFER_RESERVE_SIZE +#define MSGPACK_ZBUFFER_RESERVE_SIZE 512 +#endif + +#ifndef MSGPACK_ZBUFFER_INIT_SIZE +#define MSGPACK_ZBUFFER_INIT_SIZE 8192 +#endif namespace msgpack { -class zbuffer : public msgpack_zbuffer { +class zbuffer { public: zbuffer(int level = Z_DEFAULT_COMPRESSION, size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE) + : data_(nullptr), init_size_(init_size) { - if (!msgpack_zbuffer_init(this, level, init_size)) { + stream_.zalloc = Z_NULL; + stream_.zfree = Z_NULL; + stream_.opaque = Z_NULL; + stream_.next_out = Z_NULL; + stream_.avail_out = 0; + if(deflateInit(&stream_, level) != Z_OK) { throw std::bad_alloc(); } } ~zbuffer() { - msgpack_zbuffer_destroy(this); + deflateEnd(&stream_); + ::free(data_); } public: void write(const char* buf, size_t len) { - if(msgpack_zbuffer_write(this, buf, len) < 0) { - throw std::bad_alloc(); - } + stream_.next_in = (Bytef*)buf; + stream_.avail_in = len; + + do { + if(stream_.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { + if(!expand()) { + throw std::bad_alloc(); + } + } + + if(deflate(&stream_, Z_NO_FLUSH) != Z_OK) { + throw std::bad_alloc(); + } + } while(stream_.avail_in > 0); } char* flush() { - char* buf = msgpack_zbuffer_flush(this); - if(!buf) { - throw std::bad_alloc(); + while(true) { + switch(deflate(&stream_, Z_FINISH)) { + case Z_STREAM_END: + return data_; + case Z_OK: + if(!expand()) { + throw std::bad_alloc(); + } + break; + default: + throw std::bad_alloc(); + } } - return buf; } char* data() { - return base::data; + return data_; } const char* data() const { - return base::data; + return data_; } size_t size() const { - return msgpack_zbuffer_size(this); + return (char*)stream_.next_out - data_; } void reset() { - if(!msgpack_zbuffer_reset(this)) { + if(deflateReset(&stream_) != Z_OK) { throw std::bad_alloc(); } + reset_buffer(); } void reset_buffer() { - msgpack_zbuffer_reset_buffer(this); + stream_.avail_out += (char*)stream_.next_out - data_; + stream_.next_out = (Bytef*)data_; } char* release_buffer() { - return msgpack_zbuffer_release_buffer(this); + char* tmp = data_; + data_ = NULL; + stream_.next_out = NULL; + stream_.avail_out = 0; + return tmp; } private: - typedef msgpack_zbuffer base; + bool expand() + { + size_t used = (char*)stream_.next_out - data_; + size_t csize = used + stream_.avail_out; + size_t nsize = (csize == 0) ? init_size_ : csize * 2; + char* tmp = (char*)::realloc(data_, nsize); + if(tmp == NULL) { + return false; + } + + data_ = tmp; + stream_.next_out = (Bytef*)(tmp + used); + stream_.avail_out = nsize - used; + + return true; + } private: zbuffer(const zbuffer&); + +private: + z_stream stream_; + char* data_; + size_t init_size_; }; diff --git a/test/fixint_c.cc b/test/fixint_c.cc index caa4d262..7cd05261 100644 --- a/test/fixint_c.cc +++ b/test/fixint_c.cc @@ -1,4 +1,4 @@ -#include +#include #include TEST(fixint, size) diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index fb35c683..937806de 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -170,10 +170,10 @@ TEST(MSGPACK, simple_buffer_float) float val2; obj.convert(&val2); - if (isnan(val1)) - EXPECT_TRUE(isnan(val2)); - else if (isinf(val1)) - EXPECT_TRUE(isinf(val2)); + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); else EXPECT_TRUE(fabs(val2 - val1) <= kEPS); } @@ -260,10 +260,10 @@ TEST(MSGPACK, simple_buffer_double) double val2; obj.convert(&val2); - if (isnan(val1)) - EXPECT_TRUE(isnan(val2)); - else if (isinf(val1)) - EXPECT_TRUE(isinf(val2)); + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); else EXPECT_TRUE(fabs(val2 - val1) <= kEPS); } @@ -901,11 +901,11 @@ public: msgpack::type::tuple tuple; o.convert(&tuple); - is_double = tuple.get<0>(); + is_double = get<0>(tuple); if (is_double) - tuple.get<1>().convert(&value.f); + get<1>(tuple).convert(&value.f); else - tuple.get<1>().convert(&value.i); + get<1>(tuple).convert(&value.i); } }; @@ -1097,7 +1097,7 @@ TEST(MSGPACK, vrefbuffer_int64) obj.convert(&val); \ EXPECT_EQ(*it, val); \ ++it; \ - msgpack_zone_free(life); \ + msgpack::zone::destroy(life); \ } \ p += sz; \ } \ diff --git a/test/streaming.cc b/test/streaming.cc index e80c671b..465dea23 100644 --- a/test/streaming.cc +++ b/test/streaming.cc @@ -69,7 +69,7 @@ public: msgpack::unpacked result; while(pac.next(&result)) { - on_message(result.get(), result.zone()); + on_message(result.get(), std::move(result.zone())); } if(pac.message_size() > 10*1024*1024) { @@ -78,7 +78,7 @@ public: } } - void on_message(msgpack::object obj, std::auto_ptr z) + void on_message(msgpack::object obj, std::unique_ptr z) { EXPECT_EQ(expect, obj.as()); } @@ -133,7 +133,7 @@ TEST(streaming, basic_compat) pac.buffer_consumed(len); while(pac.execute()) { - std::auto_ptr z(pac.release_zone()); + std::unique_ptr z(pac.release_zone()); msgpack::object obj = pac.data(); pac.reset(); @@ -174,10 +174,10 @@ public: pac.buffer_consumed(len); while(pac.execute()) { - std::auto_ptr z(pac.release_zone()); + std::unique_ptr z(pac.release_zone()); msgpack::object obj = pac.data(); pac.reset(); - on_message(obj, z); + on_message(obj, std::move(z)); } if(pac.message_size() > 10*1024*1024) { @@ -186,7 +186,7 @@ public: } } - void on_message(msgpack::object obj, std::auto_ptr z) + void on_message(msgpack::object obj, std::unique_ptr z) { EXPECT_EQ(expect, obj.as()); } diff --git a/test/zone.cc b/test/zone.cc index 5274e9f0..be7b89fc 100644 --- a/test/zone.cc +++ b/test/zone.cc @@ -60,11 +60,11 @@ TEST(zone, push_finalizer) } -TEST(zone, push_finalizer_auto_ptr) +TEST(zone, push_finalizer_unique_ptr) { msgpack::zone z; - std::auto_ptr am(new myclass()); - z.push_finalizer(am); + std::unique_ptr am(new myclass()); + z.push_finalizer(std::move(am)); } From 7eccd1029ae29ea1052ae91ad6f6e4374023f6cf Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 26 Aug 2013 17:05:30 +0900 Subject: [PATCH 002/153] Modified from ::msgpack to msgpack --- src/msgpack/unpack.hpp | 94 +++++++++++++++++++++--------------------- 1 file changed, 47 insertions(+), 47 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 2b7c0b17..16354c9f 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -53,74 +53,74 @@ struct unpack_user { }; -static inline ::msgpack::object template_callback_root(unpack_user* u) -{ ::msgpack::object o = {}; return o; } +static inline msgpack::object template_callback_root(unpack_user* u) +{ msgpack::object o = {}; return o; } -static inline int template_callback_uint8(unpack_user* u, uint8_t d, ::msgpack::object* o) -{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack::object* o) +{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_uint16(unpack_user* u, uint16_t d, ::msgpack::object* o) -{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack::object* o) +{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_uint32(unpack_user* u, uint32_t d, ::msgpack::object* o) -{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack::object* o) +{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_uint64(unpack_user* u, uint64_t d, ::msgpack::object* o) -{ o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack::object* o) +{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_int8(unpack_user* u, int8_t d, ::msgpack::object* o) -{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack::object* o) +{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_int16(unpack_user* u, int16_t d, ::msgpack::object* o) -{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack::object* o) +{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_int32(unpack_user* u, int32_t d, ::msgpack::object* o) -{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack::object* o) +{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_int64(unpack_user* u, int64_t d, ::msgpack::object* o) -{ if(d >= 0) { o->type = ::msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = ::msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack::object* o) +{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_float(unpack_user* u, float d, ::msgpack::object* o) -{ o->type = ::msgpack::type::DOUBLE; o->via.dec = d; return 0; } +static inline int template_callback_float(unpack_user* u, float d, msgpack::object* o) +{ o->type = msgpack::type::DOUBLE; o->via.dec = d; return 0; } -static inline int template_callback_double(unpack_user* u, double d, ::msgpack::object* o) -{ o->type = ::msgpack::type::DOUBLE; o->via.dec = d; return 0; } +static inline int template_callback_double(unpack_user* u, double d, msgpack::object* o) +{ o->type = msgpack::type::DOUBLE; o->via.dec = d; return 0; } -static inline int template_callback_nil(unpack_user* u, ::msgpack::object* o) -{ o->type = ::msgpack::type::NIL; return 0; } +static inline int template_callback_nil(unpack_user* u, msgpack::object* o) +{ o->type = msgpack::type::NIL; return 0; } -static inline int template_callback_true(unpack_user* u, ::msgpack::object* o) -{ o->type = ::msgpack::type::BOOLEAN; o->via.boolean = true; return 0; } +static inline int template_callback_true(unpack_user* u, msgpack::object* o) +{ o->type = msgpack::type::BOOLEAN; o->via.boolean = true; return 0; } -static inline int template_callback_false(unpack_user* u, ::msgpack::object* o) -{ o->type = ::msgpack::type::BOOLEAN; o->via.boolean = false; return 0; } +static inline int template_callback_false(unpack_user* u, msgpack::object* o) +{ o->type = msgpack::type::BOOLEAN; o->via.boolean = false; return 0; } -static inline int template_callback_array(unpack_user* u, unsigned int n, ::msgpack::object* o) +static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack::object* o) { - o->type = ::msgpack::type::ARRAY; + o->type = msgpack::type::ARRAY; o->via.array.size = 0; - o->via.array.ptr = (::msgpack::object*)u->z->malloc(n*sizeof(::msgpack::object)); + o->via.array.ptr = (msgpack::object*)u->z->malloc(n*sizeof(msgpack::object)); if(o->via.array.ptr == NULL) { return -1; } return 0; } -static inline int template_callback_array_item(unpack_user* u, ::msgpack::object* c, ::msgpack::object o) +static inline int template_callback_array_item(unpack_user* u, msgpack::object* c, msgpack::object o) { c->via.array.ptr[c->via.array.size++] = o; return 0; } -static inline int template_callback_map(unpack_user* u, unsigned int n, ::msgpack::object* o) +static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack::object* o) { - o->type = ::msgpack::type::MAP; + o->type = msgpack::type::MAP; o->via.map.size = 0; - o->via.map.ptr = (::msgpack::object_kv*)u->z->malloc(n*sizeof(::msgpack::object_kv)); + o->via.map.ptr = (msgpack::object_kv*)u->z->malloc(n*sizeof(msgpack::object_kv)); if(o->via.map.ptr == NULL) { return -1; } return 0; } -static inline int template_callback_map_item(unpack_user* u, ::msgpack::object* c, ::msgpack::object k, ::msgpack::object v) +static inline int template_callback_map_item(unpack_user* u, msgpack::object* c, msgpack::object k, msgpack::object v) { c->via.map.ptr[c->via.map.size].key = k; c->via.map.ptr[c->via.map.size].val = v; @@ -128,9 +128,9 @@ static inline int template_callback_map_item(unpack_user* u, ::msgpack::object* return 0; } -static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, ::msgpack::object* o) +static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack::object* o) { - o->type = ::msgpack::type::RAW; + o->type = msgpack::type::RAW; o->via.raw.ptr = p; o->via.raw.size = l; u->referenced = true; @@ -139,10 +139,10 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha struct template_unpack_stack { - ::msgpack::object obj; + msgpack::object obj; size_t count; unsigned int ct; - ::msgpack::object map_key; + msgpack::object map_key; }; struct template_context { @@ -186,7 +186,7 @@ inline void template_init(template_context& ctx) ctx.stack[0].obj = template_callback_root(&ctx.user); } -::msgpack::object template_data(template_context const& ctx) +msgpack::object template_data(template_context const& ctx) { return ctx.stack[0].obj; } @@ -214,7 +214,7 @@ int template_execute(template_context& ctx, const char* data, size_t len, size_t */ unpack_user* user = &ctx.user; - ::msgpack::object obj; + msgpack::object obj; detail::template_unpack_stack* c = nullptr; int ret; @@ -915,7 +915,7 @@ namespace detail { inline unpack_return unpack_imp(const char* data, size_t len, size_t* off, - zone* result_zone, ::msgpack::object* result) + zone* result_zone, msgpack::object* result) { size_t noff = 0; if(off != NULL) { noff = *off; } From ec5c1194fcc01c1c46ac1ea514c2d72f54bf1527 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 26 Aug 2013 17:22:02 +0900 Subject: [PATCH 003/153] Removed redundant namespace scope resolutions. --- src/msgpack/unpack.hpp | 112 ++++++++++++++++++++--------------------- 1 file changed, 56 insertions(+), 56 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 16354c9f..a78c608b 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -53,74 +53,74 @@ struct unpack_user { }; -static inline msgpack::object template_callback_root(unpack_user* u) -{ msgpack::object o = {}; return o; } +static inline object template_callback_root(unpack_user* u) +{ object o = {}; return o; } -static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack::object* o) -{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint8(unpack_user* u, uint8_t d, object* o) +{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack::object* o) -{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint16(unpack_user* u, uint16_t d, object* o) +{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack::object* o) -{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint32(unpack_user* u, uint32_t d, object* o) +{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack::object* o) -{ o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +static inline int template_callback_uint64(unpack_user* u, uint64_t d, object* o) +{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } -static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack::object* o) -{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int8(unpack_user* u, int8_t d, object* o) +{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack::object* o) -{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int16(unpack_user* u, int16_t d, object* o) +{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack::object* o) -{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int32(unpack_user* u, int32_t d, object* o) +{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack::object* o) -{ if(d >= 0) { o->type = msgpack::type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = msgpack::type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +static inline int template_callback_int64(unpack_user* u, int64_t d, object* o) +{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } + else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } -static inline int template_callback_float(unpack_user* u, float d, msgpack::object* o) -{ o->type = msgpack::type::DOUBLE; o->via.dec = d; return 0; } +static inline int template_callback_float(unpack_user* u, float d, object* o) +{ o->type = type::DOUBLE; o->via.dec = d; return 0; } -static inline int template_callback_double(unpack_user* u, double d, msgpack::object* o) -{ o->type = msgpack::type::DOUBLE; o->via.dec = d; return 0; } +static inline int template_callback_double(unpack_user* u, double d, object* o) +{ o->type = type::DOUBLE; o->via.dec = d; return 0; } -static inline int template_callback_nil(unpack_user* u, msgpack::object* o) -{ o->type = msgpack::type::NIL; return 0; } +static inline int template_callback_nil(unpack_user* u, object* o) +{ o->type = type::NIL; return 0; } -static inline int template_callback_true(unpack_user* u, msgpack::object* o) -{ o->type = msgpack::type::BOOLEAN; o->via.boolean = true; return 0; } +static inline int template_callback_true(unpack_user* u, object* o) +{ o->type = type::BOOLEAN; o->via.boolean = true; return 0; } -static inline int template_callback_false(unpack_user* u, msgpack::object* o) -{ o->type = msgpack::type::BOOLEAN; o->via.boolean = false; return 0; } +static inline int template_callback_false(unpack_user* u, object* o) +{ o->type = type::BOOLEAN; o->via.boolean = false; return 0; } -static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack::object* o) +static inline int template_callback_array(unpack_user* u, unsigned int n, object* o) { - o->type = msgpack::type::ARRAY; + o->type = type::ARRAY; o->via.array.size = 0; - o->via.array.ptr = (msgpack::object*)u->z->malloc(n*sizeof(msgpack::object)); + o->via.array.ptr = (object*)u->z->malloc(n*sizeof(object)); if(o->via.array.ptr == NULL) { return -1; } return 0; } -static inline int template_callback_array_item(unpack_user* u, msgpack::object* c, msgpack::object o) +static inline int template_callback_array_item(unpack_user* u, object* c, object o) { c->via.array.ptr[c->via.array.size++] = o; return 0; } -static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack::object* o) +static inline int template_callback_map(unpack_user* u, unsigned int n, object* o) { - o->type = msgpack::type::MAP; + o->type = type::MAP; o->via.map.size = 0; - o->via.map.ptr = (msgpack::object_kv*)u->z->malloc(n*sizeof(msgpack::object_kv)); + o->via.map.ptr = (object_kv*)u->z->malloc(n*sizeof(object_kv)); if(o->via.map.ptr == NULL) { return -1; } return 0; } -static inline int template_callback_map_item(unpack_user* u, msgpack::object* c, msgpack::object k, msgpack::object v) +static inline int template_callback_map_item(unpack_user* u, object* c, object k, object v) { c->via.map.ptr[c->via.map.size].key = k; c->via.map.ptr[c->via.map.size].val = v; @@ -128,9 +128,9 @@ static inline int template_callback_map_item(unpack_user* u, msgpack::object* c, return 0; } -static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack::object* o) +static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, object* o) { - o->type = msgpack::type::RAW; + o->type = type::RAW; o->via.raw.ptr = p; o->via.raw.size = l; u->referenced = true; @@ -139,10 +139,10 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha struct template_unpack_stack { - msgpack::object obj; + object obj; size_t count; unsigned int ct; - msgpack::object map_key; + object map_key; }; struct template_context { @@ -186,7 +186,7 @@ inline void template_init(template_context& ctx) ctx.stack[0].obj = template_callback_root(&ctx.user); } -msgpack::object template_data(template_context const& ctx) +object template_data(template_context const& ctx) { return ctx.stack[0].obj; } @@ -208,14 +208,14 @@ int template_execute(template_context& ctx, const char* data, size_t len, size_t unsigned int trail = ctx.trail; unsigned int cs = ctx.cs; unsigned int top = ctx.top; - detail::template_unpack_stack* stack = ctx.stack; + template_unpack_stack* stack = ctx.stack; /* unsigned int stack_size = ctx.stack_size; */ unpack_user* user = &ctx.user; - msgpack::object obj; - detail::template_unpack_stack* c = nullptr; + object obj; + template_unpack_stack* c = nullptr; int ret; @@ -555,7 +555,7 @@ public: // Basic usage of the unpacker is as following: // - // msgpack::unpacker pac; + // unpacker pac; // while( /* input is readable */ ) { // // // 1. @@ -570,15 +570,15 @@ public: // pac.buffer_consumed(bytes); // // // 4. - // msgpack::unpacked result; + // unpacked result; // while(pac.next(&result)) { // // do some with the object with the zone. - // msgpack::object obj = result.get(); + // object obj = result.get(); // std::auto_ptr z = result.zone(); // on_message(obj, z); // // //// boost::shared_ptr is also usable: - // // boost::shared_ptr life(z.release()); + // // boost::shared_ptr life(z.release()); // // on_message(result.get(), life); // } // @@ -915,7 +915,7 @@ namespace detail { inline unpack_return unpack_imp(const char* data, size_t len, size_t* off, - zone* result_zone, msgpack::object* result) + zone* result_zone, object* result) { size_t noff = 0; if(off != NULL) { noff = *off; } @@ -956,8 +956,8 @@ unpack_imp(const char* data, size_t len, size_t* off, inline void unpack(unpacked* result, const char* data, size_t len, size_t* offset) { - msgpack::object obj; - std::unique_ptr z(new zone()); + object obj; + std::unique_ptr z(new zone()); unpack_return ret = detail::unpack_imp( data, len, offset, z.get(), &obj); @@ -997,7 +997,7 @@ inline object unpack(const char* data, size_t len, zone& z, size_t* off) { object result; - switch( msgpack::unpack(data, len, off, &z, &result) ) { + switch( unpack(data, len, off, &z, &result) ) { case UNPACK_SUCCESS: return result; From 11afd4820f4d1120752e8f87d51e7fe224b93b6c Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 27 Aug 2013 11:24:48 +0900 Subject: [PATCH 004/153] Modified unpack functions to class member functions. --- src/msgpack/unpack.hpp | 635 +++++++++++++++++++++-------------------- 1 file changed, 331 insertions(+), 304 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index a78c608b..8f9c62f8 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -47,12 +47,17 @@ namespace msgpack { namespace detail { -struct unpack_user { - zone* z; - bool referenced; +class unpack_user { +public: + zone* z() const { return z_; } + void set_z(zone* z) { z_ = z; } + bool referenced() const { return referenced_; } + void set_referenced(bool referenced) { referenced_ = referenced; } +private: + zone* z_; + bool referenced_; }; - static inline object template_callback_root(unpack_user* u) { object o = {}; return o; } @@ -103,7 +108,7 @@ static inline int template_callback_array(unpack_user* u, unsigned int n, object { o->type = type::ARRAY; o->via.array.size = 0; - o->via.array.ptr = (object*)u->z->malloc(n*sizeof(object)); + o->via.array.ptr = (object*)u->z()->malloc(n*sizeof(object)); if(o->via.array.ptr == NULL) { return -1; } return 0; } @@ -115,7 +120,7 @@ static inline int template_callback_map(unpack_user* u, unsigned int n, object* { o->type = type::MAP; o->via.map.size = 0; - o->via.map.ptr = (object_kv*)u->z->malloc(n*sizeof(object_kv)); + o->via.map.ptr = (object_kv*)u->z()->malloc(n*sizeof(object_kv)); if(o->via.map.ptr == NULL) { return -1; } return 0; } @@ -133,27 +138,30 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha o->type = type::RAW; o->via.raw.ptr = p; o->via.raw.size = l; - u->referenced = true; + u->set_referenced(true); return 0; } -struct template_unpack_stack { - object obj; - size_t count; - unsigned int ct; - object map_key; +class template_unpack_stack { +public: + object obj() const { return obj_; } + object& obj() { return obj_; } + void setObj(object obj) { obj_ = obj; } + size_t count() const { return count_; } + void set_count(size_t count) { count_ = count; } + size_t decl_count() { return --count_; } + unsigned int ct() const { return ct_; } + void set_ct(unsigned int ct) { ct_ = ct; } + object map_key() const { return map_key_; } + void set_map_key(object map_key) { map_key_ = map_key; } +private: + object obj_; + size_t count_; + unsigned int ct_; + object map_key_; }; -struct template_context { - unpack_user user; - unsigned int cs; - unsigned int trail; - unsigned int top; - template_unpack_stack stack[MSGPACK_EMBED_STACK_SIZE]; -}; - - inline void init_count(void* buffer) { *(volatile _msgpack_atomic_counter_t*)buffer = 1; @@ -178,161 +186,169 @@ inline _msgpack_atomic_counter_t get_count(void* buffer) return *(volatile _msgpack_atomic_counter_t*)buffer; } -inline void template_init(template_context& ctx) -{ - ctx.cs = CS_HEADER; - ctx.trail = 0; - ctx.top = 0; - ctx.stack[0].obj = template_callback_root(&ctx.user); -} +class template_context { +public: + template_context():cs_(CS_HEADER), trail_(0), top_(0) + { + stack_[0].setObj(template_callback_root(&user_)); + } -object template_data(template_context const& ctx) -{ - return ctx.stack[0].obj; -} + void init() + { + cs_ = CS_HEADER; + trail_ = 0; + top_ = 0; + stack_[0].setObj(template_callback_root(&user_)); + } -template -inline unsigned int next_cs(T p) -{ - return (unsigned int)*p & 0x1f; -} + object data() const + { + return stack_[0].obj(); + } -int template_execute(template_context& ctx, const char* data, size_t len, size_t* off) -{ - assert(len >= *off); + unpack_user& user() + { + return user_; + } - const unsigned char* p = (unsigned char*)data + *off; - const unsigned char* const pe = (unsigned char*)data + len; - const void* n = nullptr; + unpack_user const& user() const + { + return user_; + } - unsigned int trail = ctx.trail; - unsigned int cs = ctx.cs; - unsigned int top = ctx.top; - template_unpack_stack* stack = ctx.stack; - /* - unsigned int stack_size = ctx.stack_size; - */ - unpack_user* user = &ctx.user; + int execute(const char* data, size_t len, size_t* off) + { + assert(len >= *off); - object obj; - template_unpack_stack* c = nullptr; + const unsigned char* p = (unsigned char*)data + *off; + const unsigned char* const pe = (unsigned char*)data + len; + const void* n = nullptr; - int ret; + unsigned int trail = trail_; + unsigned int cs = cs_; + unsigned int top = top_; + template_unpack_stack* stack = stack_; + unpack_user* user = &user_; + + object obj; + template_unpack_stack* c = nullptr; + + int ret; - if(p == pe) { goto _out; } - do { - switch(cs) { - case CS_HEADER: - if (0) { - } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum - if(template_callback_uint8(user, *(uint8_t*)p, &obj) < 0) { goto _failed; } - goto _push; - } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum - if(template_callback_int8(user, *(int8_t*)p, &obj) < 0) { goto _failed; } - goto _push; - } else if(0xc0 <= *p && *p <= 0xdf) { // Variable - switch(*p) { - case 0xc0: // nil - if(template_callback_nil(user, &obj) < 0) { goto _failed; } + if(p == pe) { goto _out; } + do { + switch(cs) { + case CS_HEADER: + if (0) { + } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum + if(template_callback_uint8(user, *(uint8_t*)p, &obj) < 0) { goto _failed; } goto _push; - //case 0xc1: // string - // again_terminal_trail(next_cs(p), p+1); - case 0xc2: // false - if(template_callback_false(user, &obj) < 0) { goto _failed; } + } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum + if(template_callback_int8(user, *(int8_t*)p, &obj) < 0) { goto _failed; } goto _push; - case 0xc3: // true - if(template_callback_true(user, &obj) < 0) { goto _failed; } - goto _push; - case 0xc4: // bin 8 - case 0xc5: // bin 16 - case 0xc6: // bin 32 - trail = 1 << (((unsigned int)*p) & 0x03); - cs = next_cs(p); + } else if(0xc0 <= *p && *p <= 0xdf) { // Variable + switch(*p) { + case 0xc0: // nil + if(template_callback_nil(user, &obj) < 0) { goto _failed; } + goto _push; + //case 0xc1: // string + // again_terminal_trail(next_cs(p), p+1); + case 0xc2: // false + if(template_callback_false(user, &obj) < 0) { goto _failed; } + goto _push; + case 0xc3: // true + if(template_callback_true(user, &obj) < 0) { goto _failed; } + goto _push; + case 0xc4: // bin 8 + case 0xc5: // bin 16 + case 0xc6: // bin 32 + trail = 1 << (((unsigned int)*p) & 0x03); + cs = next_cs(p); + goto _fixed_trail_again; + + //case 0xc7: + //case 0xc8: + //case 0xc9: + case 0xca: // float + case 0xcb: // double + case 0xcc: // unsigned int 8 + case 0xcd: // unsigned int 16 + case 0xce: // unsigned int 32 + case 0xcf: // unsigned int 64 + case 0xd0: // signed int 8 + case 0xd1: // signed int 16 + case 0xd2: // signed int 32 + case 0xd3: // signed int 64 + trail = 1 << (((unsigned int)*p) & 0x03); + cs = next_cs(p); + goto _fixed_trail_again; + //case 0xd4: + //case 0xd5: + //case 0xd6: // big integer 16 + //case 0xd7: // big integer 32 + //case 0xd8: // big float 16 + case 0xd9: // raw 8 (str 8) + case 0xda: // raw 16 (str 16) + case 0xdb: // raw 32 (str 32) + trail = 1 << ((((unsigned int)*p) & 0x03) - 1); + cs = next_cs(p); + goto _fixed_trail_again; + case 0xdc: // array 16 + case 0xdd: // array 32 + case 0xde: // map 16 + case 0xdf: // map 32 + trail = 2 << (((unsigned int)*p) & 0x01); + cs = next_cs(p); + goto _fixed_trail_again; + default: + goto _failed; + } + } else if(0xa0 <= *p && *p <= 0xbf) { // FixRaw + trail = (unsigned int)*p & 0x1f; + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; goto _fixed_trail_again; - //case 0xc7: - //case 0xc8: - //case 0xc9: - case 0xca: // float - case 0xcb: // double - case 0xcc: // unsigned int 8 - case 0xcd: // unsigned int 16 - case 0xce: // unsigned int 32 - case 0xcf: // unsigned int 64 - case 0xd0: // signed int 8 - case 0xd1: // signed int 16 - case 0xd2: // signed int 32 - case 0xd3: // signed int 64 - trail = 1 << (((unsigned int)*p) & 0x03); - cs = next_cs(p); - goto _fixed_trail_again; - //case 0xd4: - //case 0xd5: - //case 0xd6: // big integer 16 - //case 0xd7: // big integer 32 - //case 0xd8: // big float 16 - case 0xd9: // raw 8 (str 8) - case 0xda: // raw 16 (str 16) - case 0xdb: // raw 32 (str 32) - trail = 1 << ((((unsigned int)*p) & 0x03) - 1); - cs = next_cs(p); - goto _fixed_trail_again; - case 0xdc: // array 16 - case 0xdd: // array 32 - case 0xde: // map 16 - case 0xdf: // map 32 - trail = 2 << (((unsigned int)*p) & 0x01); - cs = next_cs(p); - goto _fixed_trail_again; - default: + } else if(0x90 <= *p && *p <= 0x9f) { // FixArray + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_array(user, ((unsigned int)*p) & 0x0f, &stack[top].obj()) < 0) { goto _failed; } + if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } + stack[top].set_ct(CT_ARRAY_ITEM); + stack[top].set_count(((unsigned int)*p) & 0x0f); + ++top; + goto _header_again; + + } else if(0x80 <= *p && *p <= 0x8f) { // FixMap + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_map(user, ((unsigned int)*p) & 0x0f, &stack[top].obj()) < 0) { goto _failed; } + if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } + stack[top].set_ct(CT_MAP_KEY); + stack[top].set_count(((unsigned int)*p) & 0x0f); + ++top; + goto _header_again; + + } else { goto _failed; } - } else if(0xa0 <= *p && *p <= 0xbf) { // FixRaw - trail = (unsigned int)*p & 0x1f; - if(trail == 0) { goto _raw_zero; } - cs = ACS_RAW_VALUE; - goto _fixed_trail_again; - - } else if(0x90 <= *p && *p <= 0x9f) { // FixArray - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, ((unsigned int)*p) & 0x0f, &stack[top].obj) < 0) { goto _failed; } - if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj; goto _push; } - stack[top].ct = CT_ARRAY_ITEM; - stack[top].count = ((unsigned int)*p) & 0x0f; - ++top; - goto _header_again; - - } else if(0x80 <= *p && *p <= 0x8f) { // FixMap - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, ((unsigned int)*p) & 0x0f, &stack[top].obj) < 0) { goto _failed; } - if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj; goto _push; } - stack[top].ct = CT_MAP_KEY; - stack[top].count = ((unsigned int)*p) & 0x0f; - ++top; - goto _header_again; - - } else { - goto _failed; - } - // end CS_HEADER + // end CS_HEADER - _fixed_trail_again: - ++p; +_fixed_trail_again: + ++p; - default: - if((size_t)(pe - p) < trail) { goto _out; } - n = p; p += trail - 1; - switch(cs) { - //case CS_ - //case CS_ - case CS_FLOAT: { + default: + if((size_t)(pe - p) < trail) { goto _out; } + n = p; p += trail - 1; + switch(cs) { + //case CS_ + //case CS_ + case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = _msgpack_load32(uint32_t,n); if(template_callback_float(user, mem.f, &obj) < 0) { goto _failed; } goto _push; } - case CS_DOUBLE: { + case CS_DOUBLE: { union { uint64_t i; double f; } mem; mem.i = _msgpack_load64(uint64_t,n); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi @@ -341,161 +357,173 @@ int template_execute(template_context& ctx, const char* data, size_t len, size_t #endif if(template_callback_double(user, mem.f, &obj) < 0) { goto _failed; } goto _push; } - case CS_UINT_8: - if(template_callback_uint8(user, *(uint8_t*)n, &obj) < 0) { goto _failed; } - goto _push; - case CS_UINT_16: - if(template_callback_uint16(user, _msgpack_load16(uint16_t,n), &obj) < 0) { goto _failed; } - goto _push; - case CS_UINT_32: - if(template_callback_uint32(user, _msgpack_load32(uint32_t,n), &obj) < 0) { goto _failed; } - goto _push; - case CS_UINT_64: - if(template_callback_uint64(user, _msgpack_load64(uint64_t,n), &obj) < 0) { goto _failed; } - goto _push; + case CS_UINT_8: + if(template_callback_uint8(user, *(uint8_t*)n, &obj) < 0) { goto _failed; } + goto _push; + case CS_UINT_16: + if(template_callback_uint16(user, _msgpack_load16(uint16_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_UINT_32: + if(template_callback_uint32(user, _msgpack_load32(uint32_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_UINT_64: + if(template_callback_uint64(user, _msgpack_load64(uint64_t,n), &obj) < 0) { goto _failed; } + goto _push; - case CS_INT_8: - if(template_callback_int8(user, *(int8_t*)n, &obj) < 0) { goto _failed; } - goto _push; - case CS_INT_16: - if(template_callback_int16(user, _msgpack_load16(int16_t,n), &obj) < 0) { goto _failed; } - goto _push; - case CS_INT_32: - if(template_callback_int32(user, _msgpack_load32(int32_t,n), &obj) < 0) { goto _failed; } - goto _push; - case CS_INT_64: - if(template_callback_int64(user, _msgpack_load64(int64_t,n), &obj) < 0) { goto _failed; } - goto _push; + case CS_INT_8: + if(template_callback_int8(user, *(int8_t*)n, &obj) < 0) { goto _failed; } + goto _push; + case CS_INT_16: + if(template_callback_int16(user, _msgpack_load16(int16_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_INT_32: + if(template_callback_int32(user, _msgpack_load32(int32_t,n), &obj) < 0) { goto _failed; } + goto _push; + case CS_INT_64: + if(template_callback_int64(user, _msgpack_load64(int64_t,n), &obj) < 0) { goto _failed; } + goto _push; - case CS_BIN_8: - case CS_RAW_8: - trail = *(uint8_t*)n; - if(trail == 0) { goto _raw_zero; } - cs = ACS_RAW_VALUE; - goto _fixed_trail_again; - case CS_BIN_16: - case CS_RAW_16: - trail = _msgpack_load16(uint16_t, n); - if(trail == 0) { goto _raw_zero; } - cs = ACS_RAW_VALUE; - goto _fixed_trail_again; - case CS_BIN_32: - case CS_RAW_32: - trail = _msgpack_load32(uint32_t, n); - if(trail == 0) { goto _raw_zero; } - cs = ACS_RAW_VALUE; - goto _fixed_trail_again; - case ACS_RAW_VALUE: - _raw_zero: - if(template_callback_raw(user, (const char*)data, (const char*)n, trail, &obj) < 0) { goto _failed; } - goto _push; - case CS_ARRAY_16: - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, _msgpack_load16(uint16_t, n), &stack[top].obj) < 0) { goto _failed; } - if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj; goto _push; } - stack[top].ct = CT_ARRAY_ITEM; - stack[top].count = _msgpack_load16(uint16_t, n); - ++top; - goto _header_again; - case CS_ARRAY_32: - /* FIXME security guard */ - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, _msgpack_load32(uint32_t, n), &stack[top].obj) < 0) { goto _failed; } - if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj; goto _push; } - stack[top].ct = CT_ARRAY_ITEM; - stack[top].count = _msgpack_load32(uint32_t, n); - ++top; - goto _header_again; + case CS_BIN_8: + case CS_RAW_8: + trail = *(uint8_t*)n; + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; + goto _fixed_trail_again; + case CS_BIN_16: + case CS_RAW_16: + trail = _msgpack_load16(uint16_t, n); + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; + goto _fixed_trail_again; + case CS_BIN_32: + case CS_RAW_32: + trail = _msgpack_load32(uint32_t, n); + if(trail == 0) { goto _raw_zero; } + cs = ACS_RAW_VALUE; + goto _fixed_trail_again; + case ACS_RAW_VALUE: +_raw_zero: + if(template_callback_raw(user, (const char*)data, (const char*)n, trail, &obj) < 0) { goto _failed; } + goto _push; + case CS_ARRAY_16: + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_array(user, _msgpack_load16(uint16_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } + stack[top].set_ct(CT_ARRAY_ITEM); + stack[top].set_count(_msgpack_load16(uint16_t, n)); + ++top; + goto _header_again; + case CS_ARRAY_32: + /* FIXME security guard */ + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_array(user, _msgpack_load32(uint32_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } + stack[top].set_ct(CT_ARRAY_ITEM); + stack[top].set_count(_msgpack_load32(uint32_t, n)); + ++top; + goto _header_again; - case CS_MAP_16: - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, _msgpack_load16(uint16_t, n), &stack[top].obj) < 0) { goto _failed; } - if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj; goto _push; } - stack[top].ct = CT_MAP_KEY; - stack[top].count = _msgpack_load16(uint16_t, n); - ++top; + case CS_MAP_16: + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_map(user, _msgpack_load16(uint16_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } + stack[top].set_ct(CT_MAP_KEY); + stack[top].set_count(_msgpack_load16(uint16_t, n)); + ++top; + goto _header_again; + case CS_MAP_32: + /* FIXME security guard */ + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ + if(template_callback_map(user, _msgpack_load32(uint32_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } + stack[top].set_ct(CT_MAP_KEY); + stack[top].set_count(_msgpack_load32(uint32_t, n)); + ++top; + goto _header_again; + + default: + goto _failed; + } + } + +_push: + if(top == 0) { goto _finish; } + c = &stack[top-1]; + switch(c->ct()) { + case CT_ARRAY_ITEM: + if(template_callback_array_item(user, &c->obj(), obj) < 0) { goto _failed; } + if(c->decl_count() == 0) { + obj = c->obj(); + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } goto _header_again; - case CS_MAP_32: - /* FIXME security guard */ - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, _msgpack_load32(uint32_t, n), &stack[top].obj) < 0) { goto _failed; } - if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj; goto _push; } - stack[top].ct = CT_MAP_KEY; - stack[top].count = _msgpack_load32(uint32_t, n); - ++top; + case CT_MAP_KEY: + c->set_map_key(obj); + c->set_ct(CT_MAP_VALUE); + goto _header_again; + case CT_MAP_VALUE: + if(template_callback_map_item(user, &c->obj(), c->map_key(), obj) < 0) { goto _failed; } + if(c->decl_count() == 0) { + obj = c->obj(); + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } + c->set_ct(CT_MAP_KEY); goto _header_again; default: goto _failed; } - } - -_push: - if(top == 0) { goto _finish; } - c = &stack[top-1]; - switch(c->ct) { - case CT_ARRAY_ITEM: - if(template_callback_array_item(user, &c->obj, obj) < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - goto _header_again; - case CT_MAP_KEY: - c->map_key = obj; - c->ct = CT_MAP_VALUE; - goto _header_again; - case CT_MAP_VALUE: - if(template_callback_map_item(user, &c->obj, c->map_key, obj) < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - c->ct = CT_MAP_KEY; - goto _header_again; - - default: - goto _failed; - } _header_again: - cs = CS_HEADER; - ++p; - } while(p != pe); - goto _out; + cs = CS_HEADER; + ++p; + } while(p != pe); + goto _out; _finish: - stack[0].obj = obj; - ++p; - ret = 1; - /*printf("-- finish --\n"); */ - goto _end; + stack[0].setObj(obj); + ++p; + ret = 1; + /*printf("-- finish --\n"); */ + goto _end; _failed: - /*printf("** FAILED **\n"); */ - ret = -1; - goto _end; + /*printf("** FAILED **\n"); */ + ret = -1; + goto _end; _out: - ret = 0; - goto _end; + ret = 0; + goto _end; _end: - ctx.cs = cs; - ctx.trail = trail; - ctx.top = top; - *off = p - (const unsigned char*)data; - - return ret; -} + cs_ = cs; + trail_ = trail; + top_ = top; + *off = p - (const unsigned char*)data; + return ret; + } +private: + template + static unsigned int next_cs(T p) + { + return (unsigned int)*p & 0x1f; + } +private: + unpack_user user_; + unsigned int cs_; + unsigned int trail_; + unsigned int top_; + template_unpack_stack stack_[MSGPACK_EMBED_STACK_SIZE]; +}; } // detail @@ -689,9 +717,9 @@ inline unpacker::unpacker(size_t initial_buffer_size) detail::init_count(buffer_); - detail::template_init(ctx_); - ctx_.user.z = z_; - ctx_.user.referenced = false; + ctx_.init(); + ctx_.user().set_z(z_); + ctx_.user().set_referenced(false); } inline unpacker::~unpacker() @@ -710,7 +738,7 @@ inline void unpacker::reserve_buffer(size_t size) inline void unpacker::expand_buffer(size_t size) { if(used_ == off_ && detail::get_count(buffer_) == 1 - && !ctx_.user.referenced) { + && !ctx_.user().referenced()) { // rewind buffer free_ += used_ - COUNTER_SIZE; used_ = COUNTER_SIZE; @@ -749,7 +777,7 @@ inline void unpacker::expand_buffer(size_t size) ::memcpy(tmp+COUNTER_SIZE, buffer_ + off_, not_parsed); - if(ctx_.user.referenced) { + if(ctx_.user().referenced()) { try { z_->push_finalizer(&detail::decl_count, buffer_); } @@ -757,7 +785,7 @@ inline void unpacker::expand_buffer(size_t size) ::free(tmp); throw; } - ctx_.user.referenced = false; + ctx_.user().set_referenced(false); } else { detail::decl_count(buffer_); } @@ -822,8 +850,7 @@ inline bool unpacker::execute() inline int unpacker::execute_imp() { size_t off = off_; - int ret = detail::template_execute(ctx_, - buffer_, used_, &off_); + int ret = ctx_.execute(buffer_, used_, &off_); if(off_ > off) { parsed_ += off_ - off; } @@ -832,7 +859,7 @@ inline int unpacker::execute_imp() inline object unpacker::data() { - return template_data(ctx_); + return ctx_.data(); } inline zone* unpacker::release_zone() @@ -848,7 +875,7 @@ inline zone* unpacker::release_zone() zone* old = z_; z_ = r; - ctx_.user.z = z_; + ctx_.user().set_z(z_); return old; } @@ -860,13 +887,13 @@ inline void unpacker::reset_zone() inline bool unpacker::flush_zone() { - if(ctx_.user.referenced) { + if(ctx_.user().referenced()) { try { z_->push_finalizer(&detail::decl_count, buffer_); } catch (...) { return false; } - ctx_.user.referenced = false; + ctx_.user().set_referenced(false); detail::incr_count(buffer_); } @@ -876,7 +903,7 @@ inline bool unpacker::flush_zone() inline void unpacker::reset() { - detail::template_init(ctx_); + ctx_.init(); // don't reset referenced flag parsed_ = 0; } @@ -926,12 +953,12 @@ unpack_imp(const char* data, size_t len, size_t* off, } detail::template_context ctx; - detail::template_init(ctx); + ctx.init(); - ctx.user.z = result_zone; - ctx.user.referenced = false; + ctx.user().set_z(result_zone); + ctx.user().set_referenced(false); - int e = detail::template_execute(ctx, data, len, &noff); + int e = ctx.execute(data, len, &noff); if(e < 0) { return UNPACK_PARSE_ERROR; } @@ -942,7 +969,7 @@ unpack_imp(const char* data, size_t len, size_t* off, return UNPACK_CONTINUE; } - *result = detail::template_data(ctx); + *result = ctx.data(); if(noff < len) { return UNPACK_EXTRA_BYTES; From 5b3a168b86b5f87593e007e68a075fa27c731c11 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 29 Aug 2013 13:44:34 +0900 Subject: [PATCH 005/153] Supported C++03. --- cpp11/tuple.hpp | 20 +-- cpp11/zone.hpp | 6 +- src/msgpack/cpp_config.hpp | 86 ++++++++++ src/msgpack/type/tuple.hpp.erb | 8 +- src/msgpack/unpack.hpp | 19 ++- src/msgpack/zone.hpp.erb | 294 ++++++++++++++++++++++++--------- test/msgpack_test.cpp | 8 +- test/streaming.cc | 12 +- test/zone.cc | 4 +- 9 files changed, 346 insertions(+), 111 deletions(-) create mode 100644 src/msgpack/cpp_config.hpp diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index 0fb015a4..a29ad257 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -19,15 +19,9 @@ #define MSGPACK_TYPE_TUPLE_HPP #include "msgpack/object.hpp" -#include +#include "msgpack/cpp_config.hpp" namespace msgpack { -namespace type { - -template -using tuple = std::tuple; - -} // type // --- Pack ( from tuple to packer stream --- template @@ -36,7 +30,7 @@ struct Packer { packer& o, const Tuple& v) { Packer::pack(o, v); - o.pack(std::get(v)); + o.pack(type::get(v)); } }; @@ -45,7 +39,7 @@ struct Packer { static void pack ( packer& o, const Tuple& v) { - o.pack(std::get<0>(v)); + o.pack(type::get<0>(v)); } }; @@ -66,7 +60,7 @@ struct Converter { object o, Tuple& v) { Converter::convert(o, v); - o.via.array.ptr[N-1].convert(v))>::type>(&std::get(v)); + o.via.array.ptr[N-1].convert(v))>::type>(&type::get(v)); } }; @@ -75,7 +69,7 @@ struct Converter { static void convert ( object o, Tuple& v) { - o.via.array.ptr[0].convert(v))>::type>(&std::get<0>(v)); + o.via.array.ptr[0].convert(v))>::type>(&type::get<0>(v)); } }; @@ -96,7 +90,7 @@ struct TupleToObjectWithZone { object::with_zone& o, const Tuple& v) { TupleToObjectWithZone::convert(o, v); - o.via.array.ptr[N-1] = object(std::get(v), o.zone); + o.via.array.ptr[N-1] = object(type::get(v), o.zone); } }; @@ -105,7 +99,7 @@ struct TupleToObjectWithZone { static void convert ( object::with_zone& o, const Tuple& v) { - o.via.array.ptr[0] = object(std::get<0>(v), o.zone); + o.via.array.ptr[0] = object(type::get<0>(v), o.zone); } }; diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index f15733ab..3f223ced 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -22,6 +22,8 @@ #include #include +#include "cpp_config.hpp" + #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 #endif @@ -158,7 +160,7 @@ public: void push_finalizer(void (*func)(void*), void* data); template - void push_finalizer(std::unique_ptr obj); + void push_finalizer(msgpack::unique_ptr obj); void clear(); @@ -250,7 +252,7 @@ inline void zone::push_finalizer(void (*func)(void*), void* data) } template -inline void zone::push_finalizer(std::unique_ptr obj) +inline void zone::push_finalizer(msgpack::unique_ptr obj) { finalizer_array_.push(&zone::object_destructor, obj.get()); obj.release(); diff --git a/src/msgpack/cpp_config.hpp b/src/msgpack/cpp_config.hpp new file mode 100644 index 00000000..9c1dbb0c --- /dev/null +++ b/src/msgpack/cpp_config.hpp @@ -0,0 +1,86 @@ +// +// MessagePack for C++ C++03/C++11 Adaptation +// +// Copyright (C) 2013 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP_CONFIG_HPP +#define MSGPACK_CPP_CONFIG_HPP + +#if defined __cplusplus +#if __cplusplus < 201103 + +#define nullptr (0) + +namespace msgpack { + +template +struct unique_ptr : std::auto_ptr { + explicit unique_ptr(T* p = 0) throw() : std::auto_ptr(p) {} + unique_ptr(unique_ptr& a) throw() : std::auto_ptr(a) {} + template + unique_ptr (unique_ptr& a) throw() : std::auto_ptr(a) {} +}; + +template +T& move(T& t) +{ + return t; +} + +template +T const& move(T const& t) +{ + return t; +} + +} // msgpack + + +#else // __cplusplus < 201103 + +#include +#include + +namespace msgpack { + // unique_ptr + using std::unique_ptr; + // using std::make_unique; // since C++14 + using std::hash; + + // utility + using std::move; + using std::swap; + + namespace type { + // tuple + using std::tuple; + using std::get; + using std::make_tuple; + using std::tie; + using std::forward_as_tuple; + using std::tuple_cat; + using std::tuple_size; + using std::tuple_element; + using std::uses_allocator; + using std::ignore; + } +} // msgpack + + +#endif // __cplusplus < 201103 + +#endif // __cplusplus + +#endif /* msgpack/cpp_config.hpp */ diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index ebef8163..1ba6dc1b 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -110,6 +110,13 @@ struct tuple, A<%=j%><%}%>> { <%0.upto(i) {|j|%> A<%=j%> a<%=j%>;<%}%> }; + +template , typename A<%=j%><%}%>> +inline typename type::tuple_element, A<%=j%><%}%>>, N>::reference get(type::tuple, A<%=j%><%}%>>& t) +{ return t.get(); } +template , typename A<%=j%><%}%>> +inline typename type::const_tuple_element, A<%=j%><%}%>>, N>::const_reference get(type::tuple, A<%=j%><%}%>> const& t) +{ return t.get(); } <%}%> inline tuple<> make_tuple() @@ -126,7 +133,6 @@ tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::tr } // namespace type - inline type::tuple<>& operator>> ( object o, type::tuple<>& v) { diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 8f9c62f8..1ad7f5a7 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -21,6 +21,7 @@ #include "object.hpp" #include "zone.hpp" #include "unpack_define.h" +#include "cpp_config.hpp" #include #include @@ -59,7 +60,7 @@ private: }; static inline object template_callback_root(unpack_user* u) -{ object o = {}; return o; } +{ object o; return o; } static inline int template_callback_uint8(unpack_user* u, uint8_t d, object* o) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } @@ -538,8 +539,8 @@ class unpacked { public: unpacked() { } - unpacked(object obj, std::unique_ptr z) : - m_obj(obj), m_zone(std::move(z)) { } + unpacked(object obj, msgpack::unique_ptr z) : + m_obj(obj), m_zone(msgpack::move(z)) { } object& get() { return m_obj; } @@ -547,15 +548,15 @@ public: const object& get() const { return m_obj; } - std::unique_ptr& zone() + msgpack::unique_ptr& zone() { return m_zone; } - const std::unique_ptr& zone() const + const msgpack::unique_ptr& zone() const { return m_zone; } private: object m_obj; - std::unique_ptr m_zone; + msgpack::unique_ptr m_zone; }; @@ -984,7 +985,7 @@ inline void unpack(unpacked* result, const char* data, size_t len, size_t* offset) { object obj; - std::unique_ptr z(new zone()); + msgpack::unique_ptr z(new zone()); unpack_return ret = detail::unpack_imp( data, len, offset, z.get(), &obj); @@ -993,12 +994,12 @@ inline void unpack(unpacked* result, switch(ret) { case UNPACK_SUCCESS: result->get() = obj; - result->zone() = std::move(z); + result->zone() = msgpack::move(z); return; case UNPACK_EXTRA_BYTES: result->get() = obj; - result->zone() = std::move(z); + result->zone() = msgpack::move(z); return; case UNPACK_CONTINUE: diff --git a/src/msgpack/zone.hpp.erb b/src/msgpack/zone.hpp.erb index b2c19db0..d8b5820a 100644 --- a/src/msgpack/zone.hpp.erb +++ b/src/msgpack/zone.hpp.erb @@ -15,146 +15,292 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_ZONE_HPP__ -#define MSGPACK_ZONE_HPP__ +#ifndef MSGPACK_ZONE_HPP +#define MSGPACK_ZONE_HPP -#include "zone.h" #include #include #include +#include "cpp_config.hpp" + +#ifndef MSGPACK_ZONE_CHUNK_SIZE +#define MSGPACK_ZONE_CHUNK_SIZE 8192 +#endif + +#ifndef MSGPACK_ZONE_ALIGN +#define MSGPACK_ZONE_ALIGN sizeof(int) +#endif + <% GENERATION_LIMIT = 15 %> namespace msgpack { +class zone { + struct finalizer { + finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} + void operator()() { func_(data_); } + void (*func_)(void*); + void* data_; + }; + struct finalizer_array { + finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} + void call() { + finalizer* fin = tail_; + for(; fin != array_; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(array_); + } + void clear() { + call(); + tail_ = array_; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = tail_; + + if(fin == end_) { + push_expand(func, data); + return; + } + + fin->func_ = func; + fin->data_ = data; + + ++tail_; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = end_ - array_; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + (finalizer*)::realloc(array_, sizeof(finalizer) * nnext); + if(!tmp) { + throw std::bad_alloc(); + } + array_ = tmp; + end_ = tmp + nnext; + tail_ = tmp + nused; + new (tail_) finalizer(func, data); -class zone : public msgpack_zone { + ++tail_; + } + finalizer* tail_; + finalizer* end_; + finalizer* array_; + }; + struct chunk { + chunk* next_; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size); + if(!c) { + throw std::bad_alloc(); + } + + head_ = c; + free_ = chunk_size; + ptr_ = ((char*)c) + sizeof(chunk); + c->next_ = nullptr; + } + ~chunk_list() + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + ::free(c); + if(n) { + c = n; + } else { + break; + } + } + } + void clear(size_t chunk_size) + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + head_->next_ = nullptr; + free_ = chunk_size; + ptr_ = ((char*)head_) + sizeof(chunk); + } + size_t free_; + char* ptr_; + chunk* head_; + }; + size_t chunk_size_; + chunk_list chunk_list_; + finalizer_array finalizer_array_; + public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); - ~zone(); + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); public: - void* malloc(size_t size); - void* malloc_no_align(size_t size); + static zone* create(size_t chunk_size); + static void destroy(zone* zone); + void* malloc(size_t size); + void* malloc_no_align(size_t size); - void push_finalizer(void (*func)(void*), void* data); + void push_finalizer(void (*func)(void*), void* data); - template - void push_finalizer(std::auto_ptr obj); + template + void push_finalizer(msgpack::unique_ptr obj); - void clear(); + void clear(); - void swap(zone& o); - static void* operator new(std::size_t size) throw(std::bad_alloc) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) throw() - { - ::free(p); - } - <%0.upto(GENERATION_LIMIT) {|i|%> - template , typename A<%=j%><%}%>> - T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); - <%}%> + void swap(zone& o); + + <%0.upto(GENERATION_LIMIT) {|i|%> + template , typename A<%=j%><%}%>> + T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); + <%}%> private: - void undo_malloc(size_t size); + void undo_malloc(size_t size); - template - static void object_destructor(void* obj); + template + static void object_destructor(void* obj); - typedef msgpack_zone base; - -private: - zone(const zone&); + void* malloc_expand(size_t size); }; - -inline zone::zone(size_t chunk_size) +inline zone* zone::create(size_t chunk_size) { - msgpack_zone_init(this, chunk_size); + zone* z = (zone*)::malloc(sizeof(zone) + chunk_size); + if (!z) { + return nullptr; + } + try { + new (z) zone(chunk_size); + } + catch (...) { + ::free(z); + return nullptr; + } + return z; } -inline zone::~zone() +inline void zone::destroy(zone* z) +{ + z->~zone(); + ::free(z); +} + +inline zone::zone(size_t chunk_size):chunk_size_(chunk_size), chunk_list_(chunk_size_) { - msgpack_zone_destroy(this); } inline void* zone::malloc(size_t size) { - void* ptr = msgpack_zone_malloc(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; + return malloc_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } inline void* zone::malloc_no_align(size_t size) { - void* ptr = msgpack_zone_malloc_no_align(this, size); - if(!ptr) { - throw std::bad_alloc(); - } - return ptr; + if(chunk_list_.free_ < size) { + return malloc_expand(size); + } + + char* ptr = chunk_list_.ptr_; + chunk_list_.free_ -= size; + chunk_list_.ptr_ += size; + + return ptr; +} + +inline void* zone::malloc_expand(size_t size) +{ + chunk_list* const cl = &chunk_list_; + + size_t sz = chunk_size_; + + while(sz < size) { + sz *= 2; + } + + chunk* c = (chunk*)::malloc(sizeof(chunk) + sz); + + char* ptr = ((char*)c) + sizeof(chunk); + + c->next_ = cl->head_; + cl->head_ = c; + cl->free_ = sz - size; + cl->ptr_ = ptr + size; + + return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - if(!msgpack_zone_push_finalizer(this, func, data)) { - throw std::bad_alloc(); - } + finalizer_array_.push(func, data); } template -inline void zone::push_finalizer(std::auto_ptr obj) +inline void zone::push_finalizer(msgpack::unique_ptr obj) { - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, obj.get())) { - throw std::bad_alloc(); - } - obj.release(); + finalizer_array_.push(&zone::object_destructor, obj.get()); + obj.release(); } inline void zone::clear() { - msgpack_zone_clear(this); + finalizer_array_.clear(); + chunk_list_.clear(chunk_size_); } inline void zone::swap(zone& o) { - msgpack_zone_swap(this, &o); + std::swap(*this, o); } template void zone::object_destructor(void* obj) { - reinterpret_cast(obj)->~T(); + reinterpret_cast(obj)->~T(); } inline void zone::undo_malloc(size_t size) { - base::chunk_list.ptr -= size; - base::chunk_list.free += size; + chunk_list_.ptr_ -= size; + chunk_list_.free_ += size; } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); - } - try { - return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); - } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); - throw; - } + void* x = malloc(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_malloc(sizeof(T)); + throw; + } + try { + return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); + } catch (...) { + --finalizer_array_.tail_; + undo_malloc(sizeof(T)); + throw; + } } <%}%> diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 937806de..b14caae1 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -1,6 +1,6 @@ #include "msgpack.hpp" -#include +#include #include #include #include @@ -901,11 +901,11 @@ public: msgpack::type::tuple tuple; o.convert(&tuple); - is_double = get<0>(tuple); + is_double = msgpack::type::get<0>(tuple); if (is_double) - get<1>(tuple).convert(&value.f); + msgpack::type::get<1>(tuple).convert(&value.f); else - get<1>(tuple).convert(&value.i); + msgpack::type::get<1>(tuple).convert(&value.i); } }; diff --git a/test/streaming.cc b/test/streaming.cc index 465dea23..551cf842 100644 --- a/test/streaming.cc +++ b/test/streaming.cc @@ -69,7 +69,7 @@ public: msgpack::unpacked result; while(pac.next(&result)) { - on_message(result.get(), std::move(result.zone())); + on_message(result.get(), msgpack::move(result.zone())); } if(pac.message_size() > 10*1024*1024) { @@ -78,7 +78,7 @@ public: } } - void on_message(msgpack::object obj, std::unique_ptr z) + void on_message(msgpack::object obj, msgpack::unique_ptr z) { EXPECT_EQ(expect, obj.as()); } @@ -133,7 +133,7 @@ TEST(streaming, basic_compat) pac.buffer_consumed(len); while(pac.execute()) { - std::unique_ptr z(pac.release_zone()); + msgpack::unique_ptr z(pac.release_zone()); msgpack::object obj = pac.data(); pac.reset(); @@ -174,10 +174,10 @@ public: pac.buffer_consumed(len); while(pac.execute()) { - std::unique_ptr z(pac.release_zone()); + msgpack::unique_ptr z(pac.release_zone()); msgpack::object obj = pac.data(); pac.reset(); - on_message(obj, std::move(z)); + on_message(obj, msgpack::move(z)); } if(pac.message_size() > 10*1024*1024) { @@ -186,7 +186,7 @@ public: } } - void on_message(msgpack::object obj, std::unique_ptr z) + void on_message(msgpack::object obj, msgpack::unique_ptr z) { EXPECT_EQ(expect, obj.as()); } diff --git a/test/zone.cc b/test/zone.cc index be7b89fc..5c771028 100644 --- a/test/zone.cc +++ b/test/zone.cc @@ -63,8 +63,8 @@ TEST(zone, push_finalizer) TEST(zone, push_finalizer_unique_ptr) { msgpack::zone z; - std::unique_ptr am(new myclass()); - z.push_finalizer(std::move(am)); + msgpack::unique_ptr am(new myclass()); + z.push_finalizer(msgpack::move(am)); } From e0d1e5c722a5f4a061d5635a2b54bf90240d1ead Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 29 Aug 2013 16:16:33 +0900 Subject: [PATCH 006/153] Modified tuple's get calling from member function to free function. --- example/protocol.cc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/example/protocol.cc b/example/protocol.cc index ddf785a7..9a969179 100644 --- a/example/protocol.cc +++ b/example/protocol.cc @@ -11,17 +11,17 @@ namespace myprotocol { Get() { } Get(uint32_t f, const std::string& k) : define_type(msgpack_type(f, k)) { } - uint32_t& flags() { return get<0>(); } - std::string& key() { return get<1>(); } + uint32_t& flags() { return msgpack::type::get<0>(*this); } + std::string& key() { return msgpack::type::get<1>(*this); } }; struct Put : define< tuple > { Put() { } Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) : define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { } - uint32_t& flags() { return get<0>(); } - std::string& key() { return get<1>(); } - raw_ref& value() { return get<2>(); } + uint32_t& flags() { return msgpack::type::get<0>(*this); } + std::string& key() { return msgpack::type::get<1>(*this); } + raw_ref& value() { return msgpack::type::get<2>(*this); } }; struct MultiGet : define< std::vector > { From 40ad7da455aeef6c7d90fc701ee03c1a708d24f4 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 30 Aug 2013 13:15:56 +0900 Subject: [PATCH 007/153] Moved gcc atomic functions from source file to header file. Moved ostream operator << from object.cpp to object.hpp Removed object.cpp Modernize configure.in --- CMakeLists.txt | 6 -- configure.in | 5 +- src/Makefile.am | 8 +-- src/{gcc_atomic.cpp => gcc_atomic.hpp} | 12 +++- src/msgpack/object.hpp | 61 ++++++++++++++++++ src/msgpack/sysdep.h | 6 ++ src/object.cpp | 87 -------------------------- 7 files changed, 79 insertions(+), 106 deletions(-) rename src/{gcc_atomic.cpp => gcc_atomic.hpp} (78%) delete mode 100644 src/object.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 79c86ba2..391b490b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -63,12 +63,6 @@ int main(int argc, char * argv[]) } " MSGPACK_ENABLE_GCC_CXX_ATOMIC) -IF (MSGPACK_ENABLE_CXX) - LIST (APPEND msgpack_SOURCES - src/object.cpp - ) -ENDIF () - IF (MSGPACK_ENABLE_GCC_CXX_ATOMIC) LIST (APPEND msgpack_SOURCES src/gcc_atomic.cpp diff --git a/configure.in b/configure.in index bb61f60d..68f47ef8 100644 --- a/configure.in +++ b/configure.in @@ -1,6 +1,6 @@ -AC_INIT(src/object.cpp) +AC_INIT([msgpack], [0.5.9]) AC_CONFIG_AUX_DIR(ac) -AM_INIT_AUTOMAKE(msgpack, 0.5.9) +AM_INIT_AUTOMAKE AC_CONFIG_HEADER(config.h) @@ -106,7 +106,6 @@ fi AM_CONDITIONAL(ENABLE_GCC_CXX_ATOMIC, test "$enable_gcc_cxx_atomic" = "yes") - major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'` minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'` AC_SUBST(VERSION_MAJOR, $major) diff --git a/src/Makefile.am b/src/Makefile.am index 93207b8c..48b9c86b 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -8,14 +8,8 @@ libmsgpack_la_SOURCES = \ vrefbuffer.c \ zone.c -if ENABLE_CXX -libmsgpack_la_SOURCES += \ - object.cpp -endif - if ENABLE_GCC_CXX_ATOMIC -libmsgpack_la_SOURCES += \ - gcc_atomic.cpp + CXXFLAGS="$CXXFLAGS -DENABLE_GCC_CXX_ATOMIC" endif diff --git a/src/gcc_atomic.cpp b/src/gcc_atomic.hpp similarity index 78% rename from src/gcc_atomic.cpp rename to src/gcc_atomic.hpp index 4389d0e8..283e9dc7 100644 --- a/src/gcc_atomic.cpp +++ b/src/gcc_atomic.hpp @@ -1,7 +1,7 @@ // -// MessagePack for C++ atomic operations +// MessagePack for C++ old gcc workaround for atomic operation // -// Copyright (C) 2008-2013 FURUHASHI Sadayuki +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -16,6 +16,10 @@ // limitations under the License. // +#ifndef MSGPACK_GCC_ATOMIC_HPP +#define MSGPACK_GCC_ATOMIC_HPP + +#ifdef ENABLE_GCC_CXX_ATOMIC #if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) #include "gcc_atomic.h" @@ -31,5 +35,7 @@ int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) return __gnu_cxx::__exchange_and_add(ptr, 1) + 1; } - #endif // old gcc workaround +#endif // ENABLE_GCC_CXX_ATOMIC + +#endif /* gcc_atomic.hpp */ diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 76fe4cae..790a1f53 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -412,6 +412,67 @@ packer& operator<< (packer& o, const object& v) } } +std::ostream& operator<< (std::ostream& s, const object o) +{ + switch(o.type) { + case type::NIL: + s << "nil"; + break; + + case type::BOOLEAN: + s << (o.via.boolean ? "true" : "false"); + break; + + case type::POSITIVE_INTEGER: + s << o.via.u64; + break; + + case type::NEGATIVE_INTEGER: + s << o.via.i64; + break; + + case type::DOUBLE: + s << o.via.dec; + break; + + case type::RAW: + (s << '"').write(o.via.raw.ptr, o.via.raw.size) << '"'; + break; + + case type::ARRAY: + s << "["; + if(o.via.array.size != 0) { + object* p(o.via.array.ptr); + s << *p; + ++p; + for(object* const pend(o.via.array.ptr + o.via.array.size); + p < pend; ++p) { + s << ", " << *p; + } + } + s << "]"; + break; + + case type::MAP: + s << "{"; + if(o.via.map.size != 0) { + object_kv* p(o.via.map.ptr); + s << p->key << "=>" << p->val; + ++p; + for(object_kv* const pend(o.via.map.ptr + o.via.map.size); + p < pend; ++p) { + s << ", " << p->key << "=>" << p->val; + } + } + s << "}"; + break; + + default: + // FIXME + s << "#"; + } + return s; +} } // namespace msgpack diff --git a/src/msgpack/sysdep.h b/src/msgpack/sysdep.h index 8f082160..3c1f8718 100644 --- a/src/msgpack/sysdep.h +++ b/src/msgpack/sysdep.h @@ -42,7 +42,13 @@ typedef long _msgpack_atomic_counter_t; #define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr) #define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr) #elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) + +#if defined(__cplusplus) +#define _msgpack_atomic_counter_header "gcc_atomic.hpp" +#else #define _msgpack_atomic_counter_header "gcc_atomic.h" +#endif + #else typedef unsigned int _msgpack_atomic_counter_t; #define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1) diff --git a/src/object.cpp b/src/object.cpp deleted file mode 100644 index dfe32bbc..00000000 --- a/src/object.cpp +++ /dev/null @@ -1,87 +0,0 @@ -// -// MessagePack for C++ dynamic typed objects -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#include "msgpack/object.hpp" - -namespace msgpack { - - -std::ostream& operator<< (std::ostream& s, const object o) -{ - switch(o.type) { - case type::NIL: - s << "nil"; - break; - - case type::BOOLEAN: - s << (o.via.boolean ? "true" : "false"); - break; - - case type::POSITIVE_INTEGER: - s << o.via.u64; - break; - - case type::NEGATIVE_INTEGER: - s << o.via.i64; - break; - - case type::DOUBLE: - s << o.via.dec; - break; - - case type::RAW: - (s << '"').write(o.via.raw.ptr, o.via.raw.size) << '"'; - break; - - case type::ARRAY: - s << "["; - if(o.via.array.size != 0) { - object* p(o.via.array.ptr); - s << *p; - ++p; - for(object* const pend(o.via.array.ptr + o.via.array.size); - p < pend; ++p) { - s << ", " << *p; - } - } - s << "]"; - break; - - case type::MAP: - s << "{"; - if(o.via.map.size != 0) { - object_kv* p(o.via.map.ptr); - s << p->key << "=>" << p->val; - ++p; - for(object_kv* const pend(o.via.map.ptr + o.via.map.size); - p < pend; ++p) { - s << ", " << p->key << "=>" << p->val; - } - } - s << "}"; - break; - - default: - // FIXME - s << "#"; - } - return s; -} - - -} // namespace msgpack - From 7d731f83a4995b400fc085b213c13962e10449a5 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 30 Aug 2013 09:52:12 +0900 Subject: [PATCH 008/153] Moved the codes in pack_template.h to pack.hpp. pack_template.h is still needed for the C version of msgpack. --- src/msgpack/pack.hpp | 739 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 653 insertions(+), 86 deletions(-) diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index 7507eeff..3f9e21a1 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -1,7 +1,7 @@ // // MessagePack for C++ serializing routine // -// Copyright (C) 2008-2010 FURUHASHI Sadayuki +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_PACK_HPP__ -#define MSGPACK_PACK_HPP__ +#ifndef MSGPACK_PACK_HPP +#define MSGPACK_PACK_HPP #include "pack_define.h" #include @@ -81,53 +81,25 @@ public: packer& pack_raw_body(const char* b, size_t l); private: - static void _pack_uint8(Stream& x, uint8_t d); - static void _pack_uint16(Stream& x, uint16_t d); - static void _pack_uint32(Stream& x, uint32_t d); - static void _pack_uint64(Stream& x, uint64_t d); - static void _pack_int8(Stream& x, int8_t d); - static void _pack_int16(Stream& x, int16_t d); - static void _pack_int32(Stream& x, int32_t d); - static void _pack_int64(Stream& x, int64_t d); + template + void pack_real_uint8(T d); + template + void pack_real_uint16(T d); + template + void pack_real_uint32(T d); + template + void pack_real_uint64(T d); + template + void pack_real_int8(T d); + template + void pack_real_int16(T d); + template + void pack_real_int32(T d); + template + void pack_real_int64(T d); - static void _pack_fix_uint8(Stream& x, uint8_t d); - static void _pack_fix_uint16(Stream& x, uint16_t d); - static void _pack_fix_uint32(Stream& x, uint32_t d); - static void _pack_fix_uint64(Stream& x, uint64_t d); - static void _pack_fix_int8(Stream& x, int8_t d); - static void _pack_fix_int16(Stream& x, int16_t d); - static void _pack_fix_int32(Stream& x, int32_t d); - static void _pack_fix_int64(Stream& x, int64_t d); - - static void _pack_char(Stream& x, char d); - - static void _pack_signed_char(Stream& x, signed char d); - static void _pack_short(Stream& x, short d); - static void _pack_int(Stream& x, int d); - static void _pack_long(Stream& x, long d); - static void _pack_long_long(Stream& x, long long d); - static void _pack_unsigned_char(Stream& x, unsigned char d); - static void _pack_unsigned_short(Stream& x, unsigned short d); - static void _pack_unsigned_int(Stream& x, unsigned int d); - static void _pack_unsigned_long(Stream& x, unsigned long d); - static void _pack_unsigned_long_long(Stream& x, unsigned long long d); - - static void _pack_float(Stream& x, float d); - static void _pack_double(Stream& x, double d); - - static void _pack_nil(Stream& x); - static void _pack_true(Stream& x); - static void _pack_false(Stream& x); - - static void _pack_array(Stream& x, size_t n); - - static void _pack_map(Stream& x, size_t n); - - static void _pack_raw(Stream& x, size_t l); - static void _pack_raw_body(Stream& x, const void* b, size_t l); - - static void append_buffer(Stream& x, const unsigned char* buf, size_t len) - { x.write((const char*)buf, len); } + void append_buffer(const unsigned char* buf, unsigned int len) + { m_stream.write((const char*)buf, len); } private: Stream& m_stream; @@ -166,8 +138,17 @@ inline void pack(Stream& s, const T& v) #define msgpack_pack_append_buffer append_buffer -#include "pack_template.h" - +#if defined(__LITTLE_ENDIAN__) +#define TAKE8_8(d) ((uint8_t*)&d)[0] +#define TAKE8_16(d) ((uint8_t*)&d)[0] +#define TAKE8_32(d) ((uint8_t*)&d)[0] +#define TAKE8_64(d) ((uint8_t*)&d)[0] +#elif defined(__BIG_ENDIAN__) +#define TAKE8_8(d) ((uint8_t*)&d)[0] +#define TAKE8_16(d) ((uint8_t*)&d)[1] +#define TAKE8_32(d) ((uint8_t*)&d)[3] +#define TAKE8_64(d) ((uint8_t*)&d)[7] +#endif template packer::packer(Stream* s) : m_stream(*s) { } @@ -181,68 +162,106 @@ packer::~packer() { } template inline packer& packer::pack_uint8(uint8_t d) -{ _pack_uint8(m_stream, d); return *this; } +{ pack_real_uint8(d); return *this; } template inline packer& packer::pack_uint16(uint16_t d) -{ _pack_uint16(m_stream, d); return *this; } +{ pack_real_uint16(d); return *this; } template inline packer& packer::pack_uint32(uint32_t d) -{ _pack_uint32(m_stream, d); return *this; } +{ pack_real_uint32(d); return *this; } template inline packer& packer::pack_uint64(uint64_t d) -{ _pack_uint64(m_stream, d); return *this; } +{ pack_real_uint64(d); return *this; } template inline packer& packer::pack_int8(int8_t d) -{ _pack_int8(m_stream, d); return *this; } +{ pack_real_int8(d); return *this; } template inline packer& packer::pack_int16(int16_t d) -{ _pack_int16(m_stream, d); return *this; } +{ pack_real_int16(d); return *this; } template inline packer& packer::pack_int32(int32_t d) -{ _pack_int32(m_stream, d); return *this; } +{ pack_real_int32(d); return *this; } template inline packer& packer::pack_int64(int64_t d) -{ _pack_int64(m_stream, d); return *this;} +{ pack_real_int64(d); return *this;} template inline packer& packer::pack_fix_uint8(uint8_t d) -{ _pack_fix_uint8(m_stream, d); return *this; } +{ + unsigned char buf[2] = {0xcc, TAKE8_8(d)}; + append_buffer(buf, 2); + return *this; +} template inline packer& packer::pack_fix_uint16(uint16_t d) -{ _pack_fix_uint16(m_stream, d); return *this; } +{ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], d); + append_buffer(buf, 3); + return *this; +} template inline packer& packer::pack_fix_uint32(uint32_t d) -{ _pack_fix_uint32(m_stream, d); return *this; } +{ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], d); + append_buffer(buf, 5); + return *this; +} template inline packer& packer::pack_fix_uint64(uint64_t d) -{ _pack_fix_uint64(m_stream, d); return *this; } +{ + unsigned char buf[9]; + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + return *this; +} template inline packer& packer::pack_fix_int8(int8_t d) -{ _pack_fix_int8(m_stream, d); return *this; } +{ + unsigned char buf[2] = {0xd0, TAKE8_8(d)}; + append_buffer(buf, 2); + return *this; +} template inline packer& packer::pack_fix_int16(int16_t d) -{ _pack_fix_int16(m_stream, d); return *this; } +{ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], d); + append_buffer(buf, 3); + return *this; +} template inline packer& packer::pack_fix_int32(int32_t d) -{ _pack_fix_int32(m_stream, d); return *this; } +{ + unsigned char buf[5]; + buf[0] = 0xd2; _msgpack_store32(&buf[1], d); + append_buffer(buf, 5); + return *this; +} template inline packer& packer::pack_fix_int64(int64_t d) -{ _pack_fix_int64(m_stream, d); return *this;} +{ + unsigned char buf[9]; + buf[0] = 0xd3; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + return *this; +} template @@ -255,19 +274,136 @@ inline packer& packer::pack_signed_char(signed char d) template inline packer& packer::pack_short(short d) -{ _pack_short(m_stream, d); return *this; } +{ +#if defined(SIZEOF_SHORT) +#if SIZEOF_SHORT == 2 + pack_real_int16(d); +#elif SIZEOF_SHORT == 4 + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#elif defined(SHRT_MAX) +#if SHRT_MAX == 0x7fff + pack_real_int16(d); +#elif SHRT_MAX == 0x7fffffff + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#else +if(sizeof(short) == 2) { + pack_real_int16(d); +} else if(sizeof(short) == 4) { + pack_real_int32(d); +} else { + pack_real_int64(d); +} +#endif + return *this; +} template inline packer& packer::pack_int(int d) -{ _pack_int(m_stream, d); return *this; } +{ +#if defined(SIZEOF_INT) +#if SIZEOF_INT == 2 + pack_real_int16(d); +#elif SIZEOF_INT == 4 + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#elif defined(INT_MAX) +#if INT_MAX == 0x7fff + pack_real_int16(d); +#elif INT_MAX == 0x7fffffff + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#else +if(sizeof(int) == 2) { + pack_real_int16(d); +} else if(sizeof(int) == 4) { + pack_real_int32(d); +} else { + pack_real_int64(d); +} +#endif + return *this; +} template inline packer& packer::pack_long(long d) -{ _pack_long(m_stream, d); return *this; } +{ +#if defined(SIZEOF_LONG) +#if SIZEOF_LONG == 2 + pack_real_int16(d); +#elif SIZEOF_LONG == 4 + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#elif defined(LONG_MAX) +#if LONG_MAX == 0x7fffL + pack_real_int16(d); +#elif LONG_MAX == 0x7fffffffL + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#else +if(sizeof(long) == 2) { + pack_real_int16(d); +} else if(sizeof(long) == 4) { + pack_real_int32(d); +} else { + pack_real_int64(d); +} +#endif + return *this; +} template inline packer& packer::pack_long_long(long long d) -{ _pack_long_long(m_stream, d); return *this; } +{ +#if defined(SIZEOF_LONG_LONG) +#if SIZEOF_LONG_LONG == 2 + pack_real_int16(d); +#elif SIZEOF_LONG_LONG == 4 + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#elif defined(LLONG_MAX) +#if LLONG_MAX == 0x7fffL + pack_real_int16(d); +#elif LLONG_MAX == 0x7fffffffL + pack_real_int32(d); +#else + pack_real_int64(d); +#endif + +#else +if(sizeof(long long) == 2) { + pack_real_int16(d); +} else if(sizeof(long long) == 4) { + pack_real_int32(d); +} else { + pack_real_int64(d); +} +#endif + return *this; +} + template inline packer& packer::pack_unsigned_char(unsigned char d) @@ -275,61 +411,492 @@ inline packer& packer::pack_unsigned_char(unsigned char d) template inline packer& packer::pack_unsigned_short(unsigned short d) -{ _pack_unsigned_short(m_stream, d); return *this; } +{ +#if defined(SIZEOF_SHORT) +#if SIZEOF_SHORT == 2 + pack_real_uint16(d); +#elif SIZEOF_SHORT == 4 + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#elif defined(USHRT_MAX) +#if USHRT_MAX == 0xffffU + pack_real_uint16(d); +#elif USHRT_MAX == 0xffffffffU + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#else +if(sizeof(unsigned short) == 2) { + pack_real_uint16(d); +} else if(sizeof(unsigned short) == 4) { + pack_real_uint32(d); +} else { + pack_real_uint64(d); +} +#endif + return *this; +} template inline packer& packer::pack_unsigned_int(unsigned int d) -{ _pack_unsigned_int(m_stream, d); return *this; } +{ +#if defined(SIZEOF_INT) +#if SIZEOF_INT == 2 + pack_real_uint16(d); +#elif SIZEOF_INT == 4 + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#elif defined(UINT_MAX) +#if UINT_MAX == 0xffffU + pack_real_uint16(d); +#elif UINT_MAX == 0xffffffffU + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#else +if(sizeof(unsigned int) == 2) { + pack_real_uint16(d); +} else if(sizeof(unsigned int) == 4) { + pack_real_uint32(d); +} else { + pack_real_uint64(d); +} +#endif + return *this; +} template inline packer& packer::pack_unsigned_long(unsigned long d) -{ _pack_unsigned_long(m_stream, d); return *this; } +{ +#if defined(SIZEOF_LONG) +#if SIZEOF_LONG == 2 + pack_real_uint16(d); +#elif SIZEOF_LONG == 4 + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#elif defined(ULONG_MAX) +#if ULONG_MAX == 0xffffUL + pack_real_uint16(d); +#elif ULONG_MAX == 0xffffffffUL + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#else +if(sizeof(unsigned long) == 2) { + pack_real_uint16(d); +} else if(sizeof(unsigned long) == 4) { + pack_real_uint32(d); +} else { + pack_real_uint64(d); +} +#endif + return *this; +} template inline packer& packer::pack_unsigned_long_long(unsigned long long d) -{ _pack_unsigned_long_long(m_stream, d); return *this; } +{ +#if defined(SIZEOF_LONG_LONG) +#if SIZEOF_LONG_LONG == 2 + pack_real_uint16(d); +#elif SIZEOF_LONG_LONG == 4 + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#elif defined(ULLONG_MAX) +#if ULLONG_MAX == 0xffffUL + pack_real_uint16(d); +#elif ULLONG_MAX == 0xffffffffUL + pack_real_uint32(d); +#else + pack_real_uint64(d); +#endif + +#else +if(sizeof(unsigned long long) == 2) { + pack_real_uint16(d); +} else if(sizeof(unsigned long long) == 4) { + pack_real_uint32(d); +} else { + pack_real_uint64(d); +} +#endif + return *this; +} template inline packer& packer::pack_float(float d) -{ _pack_float(m_stream, d); return *this; } +{ + union { float f; uint32_t i; } mem; + mem.f = d; + unsigned char buf[5]; + buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); + append_buffer(buf, 5); + return *this; +} template inline packer& packer::pack_double(double d) -{ _pack_double(m_stream, d); return *this; } +{ + union { double f; uint64_t i; } mem; + mem.f = d; + unsigned char buf[9]; + buf[0] = 0xcb; +#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); +#endif + _msgpack_store64(&buf[1], mem.i); + append_buffer(buf, 9); + return *this; +} template inline packer& packer::pack_nil() -{ _pack_nil(m_stream); return *this; } +{ + static const unsigned char d = 0xc0; + append_buffer(&d, 1); + return *this; +} template inline packer& packer::pack_true() -{ _pack_true(m_stream); return *this; } +{ + static const unsigned char d = 0xc3; + append_buffer(&d, 1); + return *this; +} template inline packer& packer::pack_false() -{ _pack_false(m_stream); return *this; } +{ + static const unsigned char d = 0xc2; + append_buffer(&d, 1); + return *this; +} template inline packer& packer::pack_array(size_t n) -{ _pack_array(m_stream, n); return *this; } - +{ + if(n < 16) { + unsigned char d = 0x90 | n; + append_buffer(&d, 1); + } else if(n < 65536) { + unsigned char buf[3]; + buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); + append_buffer(buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); + append_buffer(buf, 5); + } + return *this; +} template inline packer& packer::pack_map(size_t n) -{ _pack_map(m_stream, n); return *this; } - +{ + if(n < 16) { + unsigned char d = 0x80 | n; + append_buffer(&TAKE8_8(d), 1); + } else if(n < 65536) { + unsigned char buf[3]; + buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); + append_buffer(buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); + append_buffer(buf, 5); + } + return *this; +} template inline packer& packer::pack_raw(size_t l) -{ _pack_raw(m_stream, l); return *this; } +{ + if(l < 32) { + unsigned char d = 0xa0 | (uint8_t)l; + append_buffer(&TAKE8_8(d), 1); + } else if(l < 65536) { + unsigned char buf[3]; + buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); + append_buffer(buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); + append_buffer(buf, 5); + } + return *this; +} template inline packer& packer::pack_raw_body(const char* b, size_t l) -{ _pack_raw_body(m_stream, b, l); return *this; } +{ + append_buffer((const unsigned char*)b, l); + return *this; +} +template +template +inline void packer::pack_real_uint8(T d) +{ + if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_8(d), 1); + } else { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_8(d)}; + append_buffer(buf, 2); + } +} + +template +template +inline void packer::pack_real_uint16(T d) +{ + if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_16(d), 1); + } else if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } +} + +template +template +inline void packer::pack_real_uint32(T d) +{ + if(d < (1<<8)) { + if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_32(d), 1); + } else { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1<<16)) { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } + } +} + +template +template +inline void packer::pack_real_uint64(T d) +{ + if(d < (1ULL<<8)) { + if(d < (1ULL<<7)) { + /* fixnum */ + append_buffer(&TAKE8_64(d), 1); + } else { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1ULL<<16)) { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } else if(d < (1ULL<<32)) { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + unsigned char buf[9]; + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } +} + +template +template +inline void packer::pack_real_int8(T d) +{ + if(d < -(1<<5)) { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_8(d)}; + append_buffer(buf, 2); + } else { + /* fixnum */ + append_buffer(&TAKE8_8(d), 1); + } +} + +template +template +inline void packer::pack_real_int16(T d) +{ + if(d < -(1<<5)) { + if(d < -(1<<7)) { + /* signed 16 */ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + append_buffer(buf, 3); + } else { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_16(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_16(d), 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } + } +} + +template +template +inline void packer::pack_real_int32(T d) +{ + if(d < -(1<<5)) { + if(d < -(1<<15)) { + /* signed 32 */ + unsigned char buf[5]; + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); + append_buffer(buf, 5); + } else if(d < -(1<<7)) { + /* signed 16 */ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + append_buffer(buf, 3); + } else { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_32(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_32(d), 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; + append_buffer(buf, 2); + } else if(d < (1<<16)) { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } + } +} + +template +template +inline void packer::pack_real_int64(T d) +{ + if(d < -(1LL<<5)) { + if(d < -(1LL<<15)) { + if(d < -(1LL<<31)) { + /* signed 64 */ + unsigned char buf[9]; + buf[0] = 0xd3; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } else { + /* signed 32 */ + unsigned char buf[5]; + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); + append_buffer(buf, 5); + } + } else { + if(d < -(1<<7)) { + /* signed 16 */ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + append_buffer(buf, 3); + } else { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_64(d)}; + append_buffer(buf, 2); + } + } + } else if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_64(d), 1); + } else { + if(d < (1LL<<16)) { + if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } + } else { + if(d < (1LL<<32)) { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + unsigned char buf[9]; + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } + } +} } // namespace msgpack From e0b42939baec85f9e43d19dbb54ef70fac0d4c5a Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 30 Aug 2013 13:42:43 +0900 Subject: [PATCH 009/153] Cleaned up include guards. --- src/gcc_atomic.h | 6 +++--- src/msgpack/object.h | 4 ++-- src/msgpack/object.hpp | 4 ++-- src/msgpack/pack.h | 4 ++-- src/msgpack/pack_define.h | 4 ++-- src/msgpack/sbuffer.h | 4 ++-- src/msgpack/sysdep.h | 4 ++-- src/msgpack/type/bool.hpp | 4 ++-- src/msgpack/type/define.hpp.erb | 4 ++-- src/msgpack/type/deque.hpp | 4 ++-- src/msgpack/type/fixint.hpp | 4 ++-- src/msgpack/type/float.hpp | 4 ++-- src/msgpack/type/int.hpp | 4 ++-- src/msgpack/type/list.hpp | 4 ++-- src/msgpack/type/map.hpp | 4 ++-- src/msgpack/type/nil.hpp | 4 ++-- src/msgpack/type/pair.hpp | 4 ++-- src/msgpack/type/raw.hpp | 4 ++-- src/msgpack/type/set.hpp | 4 ++-- src/msgpack/type/string.hpp | 4 ++-- src/msgpack/type/tr1/unordered_map.hpp | 4 ++-- src/msgpack/type/tr1/unordered_set.hpp | 4 ++-- src/msgpack/type/tuple.hpp.erb | 4 ++-- src/msgpack/type/vector.hpp | 4 ++-- src/msgpack/unpack.h | 4 ++-- src/msgpack/unpack_define.h | 4 ++-- src/msgpack/version.h.in | 4 ++-- src/msgpack/vrefbuffer.h | 4 ++-- src/msgpack/zbuffer.h | 4 ++-- src/msgpack/zone.h | 4 ++-- 30 files changed, 61 insertions(+), 61 deletions(-) diff --git a/src/gcc_atomic.h b/src/gcc_atomic.h index 842a48fb..276acdc9 100644 --- a/src/gcc_atomic.h +++ b/src/gcc_atomic.h @@ -12,8 +12,8 @@ * limitations under the License. */ -#ifndef MSGPACK_GCC_ATOMIC_H__ -#define MSGPACK_GCC_ATOMIC_H__ +#ifndef MSGPACK_GCC_ATOMIC_H +#define MSGPACK_GCC_ATOMIC_H #if defined(__cplusplus) extern "C" { @@ -30,4 +30,4 @@ int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); #endif -#endif // MSGPACK_GCC_ATOMIC_H__ +#endif // MSGPACK_GCC_ATOMIC_H diff --git a/src/msgpack/object.h b/src/msgpack/object.h index baeeb9b2..86927c39 100644 --- a/src/msgpack/object.h +++ b/src/msgpack/object.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_OBJECT_H__ -#define MSGPACK_OBJECT_H__ +#ifndef MSGPACK_OBJECT_H +#define MSGPACK_OBJECT_H #include "zone.h" #include diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 790a1f53..1f2de2b5 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_OBJECT_HPP__ -#define MSGPACK_OBJECT_HPP__ +#ifndef MSGPACK_OBJECT_HPP +#define MSGPACK_OBJECT_HPP #include "object.h" #include "pack.hpp" diff --git a/src/msgpack/pack.h b/src/msgpack/pack.h index 2502bd6a..691a89d4 100644 --- a/src/msgpack/pack.h +++ b/src/msgpack/pack.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_PACK_H__ -#define MSGPACK_PACK_H__ +#ifndef MSGPACK_PACK_H +#define MSGPACK_PACK_H #include "pack_define.h" #include "object.h" diff --git a/src/msgpack/pack_define.h b/src/msgpack/pack_define.h index 4845d52e..991ee5c5 100644 --- a/src/msgpack/pack_define.h +++ b/src/msgpack/pack_define.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_PACK_DEFINE_H__ -#define MSGPACK_PACK_DEFINE_H__ +#ifndef MSGPACK_PACK_DEFINE_H +#define MSGPACK_PACK_DEFINE_H #include "msgpack/sysdep.h" #include diff --git a/src/msgpack/sbuffer.h b/src/msgpack/sbuffer.h index 4ffb0b7c..5a18cf38 100644 --- a/src/msgpack/sbuffer.h +++ b/src/msgpack/sbuffer.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_SBUFFER_H__ -#define MSGPACK_SBUFFER_H__ +#ifndef MSGPACK_SBUFFER_H +#define MSGPACK_SBUFFER_H #include #include diff --git a/src/msgpack/sysdep.h b/src/msgpack/sysdep.h index 3c1f8718..f4776718 100644 --- a/src/msgpack/sysdep.h +++ b/src/msgpack/sysdep.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_SYSDEP_H__ -#define MSGPACK_SYSDEP_H__ +#ifndef MSGPACK_SYSDEP_H +#define MSGPACK_SYSDEP_H #include #include diff --git a/src/msgpack/type/bool.hpp b/src/msgpack/type/bool.hpp index 9433a982..c689f643 100644 --- a/src/msgpack/type/bool.hpp +++ b/src/msgpack/type/bool.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_BOOL_HPP__ -#define MSGPACK_TYPE_BOOL_HPP__ +#ifndef MSGPACK_TYPE_BOOL_HPP +#define MSGPACK_TYPE_BOOL_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb index cc06be9c..331bbce4 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/src/msgpack/type/define.hpp.erb @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_DEFINE_HPP__ -#define MSGPACK_TYPE_DEFINE_HPP__ +#ifndef MSGPACK_TYPE_DEFINE_HPP +#define MSGPACK_TYPE_DEFINE_HPP #define MSGPACK_DEFINE(...) \ template \ diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp index d21ceeae..dcce1dc7 100644 --- a/src/msgpack/type/deque.hpp +++ b/src/msgpack/type/deque.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_DEQUE_HPP__ -#define MSGPACK_TYPE_DEQUE_HPP__ +#ifndef MSGPACK_TYPE_DEQUE_HPP +#define MSGPACK_TYPE_DEQUE_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/fixint.hpp b/src/msgpack/type/fixint.hpp index ebe2696f..4f0289da 100644 --- a/src/msgpack/type/fixint.hpp +++ b/src/msgpack/type/fixint.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_FIXINT_HPP__ -#define MSGPACK_TYPE_FIXINT_HPP__ +#ifndef MSGPACK_TYPE_FIXINT_HPP +#define MSGPACK_TYPE_FIXINT_HPP #include "msgpack/object.hpp" #include "msgpack/type/int.hpp" diff --git a/src/msgpack/type/float.hpp b/src/msgpack/type/float.hpp index 6ba06d5c..823757cd 100644 --- a/src/msgpack/type/float.hpp +++ b/src/msgpack/type/float.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_FLOAT_HPP__ -#define MSGPACK_TYPE_FLOAT_HPP__ +#ifndef MSGPACK_TYPE_FLOAT_HPP +#define MSGPACK_TYPE_FLOAT_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/int.hpp b/src/msgpack/type/int.hpp index 6a1477ee..b1af29fe 100644 --- a/src/msgpack/type/int.hpp +++ b/src/msgpack/type/int.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_INT_HPP__ -#define MSGPACK_TYPE_INT_HPP__ +#ifndef MSGPACK_TYPE_INT_HPP +#define MSGPACK_TYPE_INT_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp index c0f8ce63..0c246f6a 100644 --- a/src/msgpack/type/list.hpp +++ b/src/msgpack/type/list.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_LIST_HPP__ -#define MSGPACK_TYPE_LIST_HPP__ +#ifndef MSGPACK_TYPE_LIST_HPP +#define MSGPACK_TYPE_LIST_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp index 958447d5..b58f5f58 100644 --- a/src/msgpack/type/map.hpp +++ b/src/msgpack/type/map.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_MAP_HPP__ -#define MSGPACK_TYPE_MAP_HPP__ +#ifndef MSGPACK_TYPE_MAP_HPP +#define MSGPACK_TYPE_MAP_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/nil.hpp b/src/msgpack/type/nil.hpp index f44e45e4..1b69f3c1 100644 --- a/src/msgpack/type/nil.hpp +++ b/src/msgpack/type/nil.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_NIL_HPP__ -#define MSGPACK_TYPE_NIL_HPP__ +#ifndef MSGPACK_TYPE_NIL_HPP +#define MSGPACK_TYPE_NIL_HPP #include "msgpack/object.hpp" diff --git a/src/msgpack/type/pair.hpp b/src/msgpack/type/pair.hpp index 296a8b64..7ed57388 100644 --- a/src/msgpack/type/pair.hpp +++ b/src/msgpack/type/pair.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_PAIR_HPP__ -#define MSGPACK_TYPE_PAIR_HPP__ +#ifndef MSGPACK_TYPE_PAIR_HPP +#define MSGPACK_TYPE_PAIR_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/raw.hpp b/src/msgpack/type/raw.hpp index 87d188f6..0f296236 100644 --- a/src/msgpack/type/raw.hpp +++ b/src/msgpack/type/raw.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_RAW_HPP__ -#define MSGPACK_TYPE_RAW_HPP__ +#ifndef MSGPACK_TYPE_RAW_HPP +#define MSGPACK_TYPE_RAW_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/set.hpp b/src/msgpack/type/set.hpp index bcf1030a..5aa9f2ae 100644 --- a/src/msgpack/type/set.hpp +++ b/src/msgpack/type/set.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_SET_HPP__ -#define MSGPACK_TYPE_SET_HPP__ +#ifndef MSGPACK_TYPE_SET_HPP +#define MSGPACK_TYPE_SET_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index 37d4a172..870517d2 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_STRING_HPP__ -#define MSGPACK_TYPE_STRING_HPP__ +#ifndef MSGPACK_TYPE_STRING_HPP +#define MSGPACK_TYPE_STRING_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp index f485c89a..88c61a87 100644 --- a/src/msgpack/type/tr1/unordered_map.hpp +++ b/src/msgpack/type/tr1/unordered_map.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__ -#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP__ +#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP #include "msgpack/object.hpp" diff --git a/src/msgpack/type/tr1/unordered_set.hpp b/src/msgpack/type/tr1/unordered_set.hpp index 252ae233..33c35929 100644 --- a/src/msgpack/type/tr1/unordered_set.hpp +++ b/src/msgpack/type/tr1/unordered_set.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__ -#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP__ +#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP #include "msgpack/object.hpp" diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index 1ba6dc1b..f4a691ca 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_TUPLE_HPP__ -#define MSGPACK_TYPE_TUPLE_HPP__ +#ifndef MSGPACK_TYPE_TUPLE_HPP +#define MSGPACK_TYPE_TUPLE_HPP #include "msgpack/object.hpp" diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp index bd073ef8..ae2da47f 100644 --- a/src/msgpack/type/vector.hpp +++ b/src/msgpack/type/vector.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_VECTOR_HPP__ -#define MSGPACK_TYPE_VECTOR_HPP__ +#ifndef MSGPACK_TYPE_VECTOR_HPP +#define MSGPACK_TYPE_VECTOR_HPP #include "msgpack/object.hpp" #include diff --git a/src/msgpack/unpack.h b/src/msgpack/unpack.h index c3380f81..c90e95af 100644 --- a/src/msgpack/unpack.h +++ b/src/msgpack/unpack.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_UNPACKER_H__ -#define MSGPACK_UNPACKER_H__ +#ifndef MSGPACK_UNPACKER_H +#define MSGPACK_UNPACKER_H #include "zone.h" #include "object.h" diff --git a/src/msgpack/unpack_define.h b/src/msgpack/unpack_define.h index c6ecb90d..4c0b9c65 100644 --- a/src/msgpack/unpack_define.h +++ b/src/msgpack/unpack_define.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_UNPACK_DEFINE_H__ -#define MSGPACK_UNPACK_DEFINE_H__ +#ifndef MSGPACK_UNPACK_DEFINE_H +#define MSGPACK_UNPACK_DEFINE_H #include "msgpack/sysdep.h" #include diff --git a/src/msgpack/version.h.in b/src/msgpack/version.h.in index f1feb331..418ae4a2 100644 --- a/src/msgpack/version.h.in +++ b/src/msgpack/version.h.in @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_VERSION_H__ -#define MSGPACK_VERSION_H__ +#ifndef MSGPACK_VERSION_H +#define MSGPACK_VERSION_H #ifdef __cplusplus extern "C" { diff --git a/src/msgpack/vrefbuffer.h b/src/msgpack/vrefbuffer.h index 23022a84..cc912b35 100644 --- a/src/msgpack/vrefbuffer.h +++ b/src/msgpack/vrefbuffer.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_VREFBUFFER_H__ -#define MSGPACK_VREFBUFFER_H__ +#ifndef MSGPACK_VREFBUFFER_H +#define MSGPACK_VREFBUFFER_H #include "zone.h" #include diff --git a/src/msgpack/zbuffer.h b/src/msgpack/zbuffer.h index 965d389b..d7f65ce9 100644 --- a/src/msgpack/zbuffer.h +++ b/src/msgpack/zbuffer.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_ZBUFFER_H__ -#define MSGPACK_ZBUFFER_H__ +#ifndef MSGPACK_ZBUFFER_H +#define MSGPACK_ZBUFFER_H #include "sysdep.h" #include diff --git a/src/msgpack/zone.h b/src/msgpack/zone.h index aa2a1470..1f68a3c4 100644 --- a/src/msgpack/zone.h +++ b/src/msgpack/zone.h @@ -15,8 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_ZONE_H__ -#define MSGPACK_ZONE_H__ +#ifndef MSGPACK_ZONE_H +#define MSGPACK_ZONE_H #include "sysdep.h" From 36a87b696848b7954dda81c464c7134c2d6cff64 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 30 Aug 2013 14:39:54 +0900 Subject: [PATCH 010/153] Replaced C-style casts with C++ stype casts in C++ codes. --- cpp11/define.hpp | 14 +++--- cpp11/tuple.hpp | 68 +++++++++++++------------- cpp11/zone.hpp | 26 +++++----- src/msgpack/sbuffer.hpp | 2 +- src/msgpack/type/define.hpp.erb | 2 +- src/msgpack/type/deque.hpp | 2 +- src/msgpack/type/int.hpp | 2 +- src/msgpack/type/list.hpp | 2 +- src/msgpack/type/map.hpp | 6 +-- src/msgpack/type/pair.hpp | 2 +- src/msgpack/type/set.hpp | 4 +- src/msgpack/type/string.hpp | 2 +- src/msgpack/type/tr1/unordered_map.hpp | 4 +- src/msgpack/type/tr1/unordered_set.hpp | 4 +- src/msgpack/type/tuple.hpp.erb | 2 +- src/msgpack/type/vector.hpp | 2 +- src/msgpack/vrefbuffer.hpp | 54 ++++++++++---------- src/msgpack/zbuffer.hpp | 12 ++--- src/msgpack/zone.hpp.erb | 14 +++--- 19 files changed, 113 insertions(+), 111 deletions(-) diff --git a/cpp11/define.hpp b/cpp11/define.hpp index 9754af27..526a4aea 100644 --- a/cpp11/define.hpp +++ b/cpp11/define.hpp @@ -74,7 +74,7 @@ struct define_imp { static void unpack(msgpack::object o, Tuple& t) { define_imp::unpack(o, t); const size_t size = o.via.array.size; - if(size <= N-1) { return; } + if(size <= N-1) { return; } o.via.array.ptr[N-1].convert(&std::get(t)); } static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { @@ -91,7 +91,7 @@ struct define_imp { } static void unpack(msgpack::object o, Tuple& t) { const size_t size = o.via.array.size; - if(size <= 0) { return; } + if(size <= 0) { return; } o.via.array.ptr[0].convert(&std::get<0>(t)); } static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { @@ -109,24 +109,24 @@ struct define { void msgpack_pack(Packer& pk) const { pk.pack_array(sizeof...(Args)); - + define_imp, sizeof...(Args)>::pack(pk, a); } void msgpack_unpack(msgpack::object o) { if(o.type != type::ARRAY) { throw type_error(); } - + define_imp, sizeof...(Args)>::unpack(o, a); } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*sizeof...(Args)); + o->via.array.ptr = static_cast(z->malloc(sizeof(object)*sizeof...(Args))); o->via.array.size = sizeof...(Args); - + define_imp, sizeof...(Args)>::object(o, z, a); } - + tuple a; }; diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index a29ad257..1a92e208 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -26,91 +26,91 @@ namespace msgpack { // --- Pack ( from tuple to packer stream --- template struct Packer { - static void pack( + static void pack( packer& o, const Tuple& v) { - Packer::pack(o, v); - o.pack(type::get(v)); - } + Packer::pack(o, v); + o.pack(type::get(v)); + } }; template struct Packer { - static void pack ( + static void pack ( packer& o, const Tuple& v) { - o.pack(type::get<0>(v)); - } + o.pack(type::get<0>(v)); + } }; template const packer& operator<< ( - packer& o, - const type::tuple& v) { + packer& o, + const type::tuple& v) { o.pack_array(sizeof...(Args)); - Packer::pack(o, v); - return o; + Packer::pack(o, v); + return o; } // --- Convert from tuple to object --- template struct Converter { - static void convert( - object o, + static void convert( + object o, Tuple& v) { - Converter::convert(o, v); - o.via.array.ptr[N-1].convert(v))>::type>(&type::get(v)); - } + Converter::convert(o, v); + o.via.array.ptr[N-1].convert(v))>::type>(&type::get(v)); + } }; template struct Converter { - static void convert ( - object o, + static void convert ( + object o, Tuple& v) { - o.via.array.ptr[0].convert(v))>::type>(&type::get<0>(v)); - } + o.via.array.ptr[0].convert(v))>::type>(&type::get<0>(v)); + } }; template type::tuple& operator>> ( - object o, - type::tuple& v) { + object o, + type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); } - Converter::convert(o, v); - return v; + Converter::convert(o, v); + return v; } // --- Convert from tuple to object with zone --- template struct TupleToObjectWithZone { - static void convert( + static void convert( object::with_zone& o, const Tuple& v) { - TupleToObjectWithZone::convert(o, v); - o.via.array.ptr[N-1] = object(type::get(v), o.zone); - } + TupleToObjectWithZone::convert(o, v); + o.via.array.ptr[N-1] = object(type::get(v), o.zone); + } }; template struct TupleToObjectWithZone { - static void convert ( + static void convert ( object::with_zone& o, const Tuple& v) { - o.via.array.ptr[0] = object(type::get<0>(v), o.zone); - } + o.via.array.ptr[0] = object(type::get<0>(v), o.zone); + } }; template inline void operator<< ( object::with_zone& o, - type::tuple& v) { + type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*sizeof...(Args)); + o.via.array.ptr = static_cast(o.zone->malloc(sizeof(object)*sizeof...(Args))); o.via.array.size = sizeof...(Args); - TupleToObjectWithZone::convert(o, v); + TupleToObjectWithZone::convert(o, v); } } // msgpack diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index 3f223ced..17a4e0dd 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -59,15 +59,15 @@ private: void push(void (*func)(void* data), void* data) { finalizer* fin = tail_; - + if(fin == end_) { push_expand(func, data); return; } - + fin->func_ = func; fin->data_ = data; - + ++tail_; } void push_expand(void (*func)(void*), void* data) { @@ -80,7 +80,7 @@ private: nnext = nused * 2; } finalizer* tmp = - (finalizer*)::realloc(array_, sizeof(finalizer) * nnext); + static_cast(::realloc(array_, sizeof(finalizer) * nnext)); if(!tmp) { throw std::bad_alloc(); } @@ -101,14 +101,14 @@ private: struct chunk_list { chunk_list(size_t chunk_size) { - chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size); + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); if(!c) { throw std::bad_alloc(); } - + head_ = c; free_ = chunk_size; - ptr_ = ((char*)c) + sizeof(chunk); + ptr_ = reinterpret_cast(c) + sizeof(chunk); c->next_ = nullptr; } ~chunk_list() @@ -138,7 +138,7 @@ private: } head_->next_ = nullptr; free_ = chunk_size; - ptr_ = ((char*)head_) + sizeof(chunk); + ptr_ = reinterpret_cast(head_) + sizeof(chunk); } size_t free_; char* ptr_; @@ -147,7 +147,7 @@ private: size_t chunk_size_; chunk_list chunk_list_; finalizer_array finalizer_array_; - + public: zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); @@ -166,7 +166,7 @@ public: void swap(zone& o); - + template T* allocate(Args... args); @@ -181,7 +181,7 @@ private: inline zone* zone::create(size_t chunk_size) { - zone* z = (zone*)::malloc(sizeof(zone) + chunk_size); + zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); if (!z) { return nullptr; } @@ -234,9 +234,9 @@ inline void* zone::malloc_expand(size_t size) sz *= 2; } - chunk* c = (chunk*)::malloc(sizeof(chunk) + sz); + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - char* ptr = ((char*)c) + sizeof(chunk); + char* ptr = reinterpret_cast(c) + sizeof(chunk); c->next_ = cl->head_; cl->head_ = c; diff --git a/src/msgpack/sbuffer.hpp b/src/msgpack/sbuffer.hpp index aa197038..3371bcb1 100644 --- a/src/msgpack/sbuffer.hpp +++ b/src/msgpack/sbuffer.hpp @@ -98,7 +98,7 @@ private: throw std::bad_alloc(); } - data_ = (char*)tmp; + data_ = static_cast(tmp); alloc_ = nsize; } diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb index 331bbce4..8aead021 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/src/msgpack/type/define.hpp.erb @@ -118,7 +118,7 @@ struct define, A<%=j%><%}%>> { void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*<%=i+1%>); + o->via.array.ptr = static_cast(z->malloc(sizeof(object)*<%=i+1%>)); o->via.array.size = <%=i+1%>; <%0.upto(i) {|j|%> o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%> diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp index dcce1dc7..cf816498 100644 --- a/src/msgpack/type/deque.hpp +++ b/src/msgpack/type/deque.hpp @@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::deque& v) o.via.array.ptr = NULL; o.via.array.size = 0; } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); + object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/int.hpp b/src/msgpack/type/int.hpp index b1af29fe..5286f010 100644 --- a/src/msgpack/type/int.hpp +++ b/src/msgpack/type/int.hpp @@ -44,7 +44,7 @@ namespace detail { throw type_error(); } }; - + template struct convert_integer_sign { static inline T convert(object o) { diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp index 0c246f6a..9367719e 100644 --- a/src/msgpack/type/list.hpp +++ b/src/msgpack/type/list.hpp @@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::list& v) o.via.array.ptr = NULL; o.via.array.size = 0; } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); + object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp index b58f5f58..589cff38 100644 --- a/src/msgpack/type/map.hpp +++ b/src/msgpack/type/map.hpp @@ -78,7 +78,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector& v) o.via.map.ptr = NULL; o.via.map.size = 0; } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); + object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -134,7 +134,7 @@ inline void operator<< (object::with_zone& o, const std::map& v) o.via.map.ptr = NULL; o.via.map.size = 0; } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); + object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -184,7 +184,7 @@ inline void operator<< (object::with_zone& o, const std::multimap& v) o.via.map.ptr = NULL; o.via.map.size = 0; } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); + object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); diff --git a/src/msgpack/type/pair.hpp b/src/msgpack/type/pair.hpp index 7ed57388..f8ff85a6 100644 --- a/src/msgpack/type/pair.hpp +++ b/src/msgpack/type/pair.hpp @@ -47,7 +47,7 @@ template inline void operator<< (object::with_zone& o, const std::pair& v) { o.type = type::ARRAY; - object* p = (object*)o.zone->malloc(sizeof(object)*2); + object* p = static_cast(o.zone->malloc(sizeof(object)*2)); o.via.array.ptr = p; o.via.array.size = 2; p[0] = object(v.first, o.zone); diff --git a/src/msgpack/type/set.hpp b/src/msgpack/type/set.hpp index 5aa9f2ae..065e69a6 100644 --- a/src/msgpack/type/set.hpp +++ b/src/msgpack/type/set.hpp @@ -56,7 +56,7 @@ inline void operator<< (object::with_zone& o, const std::set& v) o.via.array.ptr = NULL; o.via.array.size = 0; } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); + object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); @@ -102,7 +102,7 @@ inline void operator<< (object::with_zone& o, const std::multiset& v) o.via.array.ptr = NULL; o.via.array.size = 0; } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); + object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index 870517d2..e7839472 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -42,7 +42,7 @@ inline packer& operator<< (packer& o, const std::string& v) inline void operator<< (object::with_zone& o, const std::string& v) { o.type = type::RAW; - char* ptr = (char*)o.zone->malloc(v.size()); + char* ptr = static_cast(o.zone->malloc(v.size())); o.via.raw.ptr = ptr; o.via.raw.size = (uint32_t)v.size(); memcpy(ptr, v.data(), v.size()); diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp index 88c61a87..bb2623ff 100644 --- a/src/msgpack/type/tr1/unordered_map.hpp +++ b/src/msgpack/type/tr1/unordered_map.hpp @@ -77,7 +77,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.map.ptr = NULL; o.via.map.size = 0; } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); + object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -127,7 +127,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.map.ptr = NULL; o.via.map.size = 0; } else { - object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size()); + object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); diff --git a/src/msgpack/type/tr1/unordered_set.hpp b/src/msgpack/type/tr1/unordered_set.hpp index 33c35929..63f37045 100644 --- a/src/msgpack/type/tr1/unordered_set.hpp +++ b/src/msgpack/type/tr1/unordered_set.hpp @@ -74,7 +74,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s o.via.array.ptr = NULL; o.via.array.size = 0; } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); + object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); @@ -120,7 +120,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.array.ptr = NULL; o.via.array.size = 0; } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); + object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index f4a691ca..4f73eb20 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -184,7 +184,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple, A<%=j%><%}%>>& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*<%=i+1%>); + o.via.array.ptr = static_cast(o.zone->malloc(sizeof(object)*<%=i+1%>)); o.via.array.size = <%=i+1%>; <%0.upto(i) {|j|%> o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%> diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp index ae2da47f..338eb8c0 100644 --- a/src/msgpack/type/vector.hpp +++ b/src/msgpack/type/vector.hpp @@ -61,7 +61,7 @@ inline void operator<< (object::with_zone& o, const std::vector& v) o.via.array.ptr = NULL; o.via.array.size = 0; } else { - object* p = (object*)o.zone->malloc(sizeof(object)*v.size()); + object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/vrefbuffer.hpp b/src/msgpack/vrefbuffer.hpp index 8d22cfea..a2f4db58 100644 --- a/src/msgpack/vrefbuffer.hpp +++ b/src/msgpack/vrefbuffer.hpp @@ -56,23 +56,23 @@ private: }; public: vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, - size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) + size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) :ref_size_(ref_size), chunk_size_(chunk_size) { size_t nfirst = (sizeof(iovec) < 72/2) ? 72 / sizeof(iovec) : 8; - iovec* array = (iovec*)::malloc( - sizeof(iovec) * nfirst); + iovec* array = static_cast(::malloc( + sizeof(iovec) * nfirst)); if(!array) { throw std::bad_alloc(); } - + tail_ = array; end_ = array + nfirst; array_ = array; - chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size); + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); if(!c) { ::free(array); throw std::bad_alloc(); @@ -80,10 +80,10 @@ public: inner_buffer* const ib = &inner_buffer_; ib->free = chunk_size; - ib->ptr = ((char*)c) + sizeof(chunk); + ib->ptr = reinterpret_cast(c) + sizeof(chunk); ib->head = c; c->next = nullptr; - + } ~vrefbuffer() @@ -117,17 +117,17 @@ public: const size_t nused = tail_ - array_; const size_t nnext = nused * 2; - iovec* nvec = (iovec*)::realloc( - array_, sizeof(iovec)*nnext); + iovec* nvec = static_cast(::realloc( + array_, sizeof(iovec)*nnext)); if(!nvec) { throw std::bad_alloc(); } - + array_ = nvec; end_ = nvec + nnext; tail_ = nvec + nused; } - + tail_->iov_base = (char*)buf; tail_->iov_len = len; ++tail_; @@ -143,24 +143,26 @@ public: sz = len; } - chunk* c = (chunk*)::malloc(sizeof(chunk) + sz); + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); if(!c) { throw std::bad_alloc(); } - + c->next = ib->head; ib->head = c; ib->free = sz; - ib->ptr = ((char*)c) + sizeof(chunk); + ib->ptr = reinterpret_cast(c) + sizeof(chunk); } char* m = ib->ptr; ::memcpy(m, buf, len); ib->free -= len; ib->ptr += len; - + if(tail_ != array_ && m == - (const char*)((tail_ - 1)->iov_base) + (tail_ - 1)->iov_len) { + static_cast( + const_cast((tail_ - 1)->iov_base) + ) + (tail_ - 1)->iov_len) { (tail_ - 1)->iov_len += len; return; } else { @@ -182,7 +184,7 @@ public: { size_t sz = chunk_size_; - chunk* empty = (chunk*)::malloc(sizeof(chunk) + sz); + chunk* empty = static_cast(::malloc(sizeof(chunk) + sz)); if(!empty) { throw std::bad_alloc(); } @@ -198,8 +200,8 @@ public: nnext *= 2; } - iovec* nvec = (iovec*)::realloc( - to->array_, sizeof(iovec)*nnext); + iovec* nvec = static_cast(::realloc( + to->array_, sizeof(iovec)*nnext)); if(!nvec) { ::free(empty); throw std::bad_alloc(); @@ -211,7 +213,7 @@ public: } ::memcpy(to->tail_, array_, sizeof(iovec)*nused); - + to->tail_ += nused; tail_ = array_; @@ -225,18 +227,18 @@ public: } last->next = toib->head; toib->head = ib->head; - + if(toib->free < ib->free) { toib->free = ib->free; toib->ptr = ib->ptr; } - + ib->head = empty; ib->free = sz; - ib->ptr = ((char*)empty) + sizeof(chunk); - + ib->ptr = reinterpret_cast(empty) + sizeof(chunk); + } - + void clear() { chunk* c = inner_buffer_.head->next; @@ -251,7 +253,7 @@ public: c = ib->head; c->next = nullptr; ib->free = chunk_size_; - ib->ptr = ((char*)c) + sizeof(chunk); + ib->ptr = reinterpret_cast(c) + sizeof(chunk); tail_ = array_; } diff --git a/src/msgpack/zbuffer.hpp b/src/msgpack/zbuffer.hpp index 1afe8025..10c0077e 100644 --- a/src/msgpack/zbuffer.hpp +++ b/src/msgpack/zbuffer.hpp @@ -57,7 +57,7 @@ public: public: void write(const char* buf, size_t len) { - stream_.next_in = (Bytef*)buf; + stream_.next_in = reinterpret_cast(const_cast(buf)); stream_.avail_in = len; do { @@ -115,8 +115,8 @@ public: void reset_buffer() { - stream_.avail_out += (char*)stream_.next_out - data_; - stream_.next_out = (Bytef*)data_; + stream_.avail_out += reinterpret_cast(stream_.next_out) - data_; + stream_.next_out = reinterpret_cast(data_); } char* release_buffer() @@ -131,17 +131,17 @@ public: private: bool expand() { - size_t used = (char*)stream_.next_out - data_; + size_t used = reinterpret_cast(stream_.next_out) - data_; size_t csize = used + stream_.avail_out; size_t nsize = (csize == 0) ? init_size_ : csize * 2; - char* tmp = (char*)::realloc(data_, nsize); + char* tmp = static_cast(::realloc(data_, nsize)); if(tmp == NULL) { return false; } data_ = tmp; - stream_.next_out = (Bytef*)(tmp + used); + stream_.next_out = reinterpret_cast(tmp + used); stream_.avail_out = nsize - used; return true; diff --git a/src/msgpack/zone.hpp.erb b/src/msgpack/zone.hpp.erb index d8b5820a..11e0fd18 100644 --- a/src/msgpack/zone.hpp.erb +++ b/src/msgpack/zone.hpp.erb @@ -80,7 +80,7 @@ class zone { nnext = nused * 2; } finalizer* tmp = - (finalizer*)::realloc(array_, sizeof(finalizer) * nnext); + static_cast(::realloc(array_, sizeof(finalizer) * nnext)); if(!tmp) { throw std::bad_alloc(); } @@ -101,14 +101,14 @@ class zone { struct chunk_list { chunk_list(size_t chunk_size) { - chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size); + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); if(!c) { throw std::bad_alloc(); } head_ = c; free_ = chunk_size; - ptr_ = ((char*)c) + sizeof(chunk); + ptr_ = reinterpret_cast(c) + sizeof(chunk); c->next_ = nullptr; } ~chunk_list() @@ -138,7 +138,7 @@ class zone { } head_->next_ = nullptr; free_ = chunk_size; - ptr_ = ((char*)head_) + sizeof(chunk); + ptr_ = reinterpret_cast(head_) + sizeof(chunk); } size_t free_; char* ptr_; @@ -183,7 +183,7 @@ private: inline zone* zone::create(size_t chunk_size) { - zone* z = (zone*)::malloc(sizeof(zone) + chunk_size); + zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); if (!z) { return nullptr; } @@ -236,9 +236,9 @@ inline void* zone::malloc_expand(size_t size) sz *= 2; } - chunk* c = (chunk*)::malloc(sizeof(chunk) + sz); + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - char* ptr = ((char*)c) + sizeof(chunk); + char* ptr = reinterpret_cast(c) + sizeof(chunk); c->next_ = cl->head_; cl->head_ = c; From da601e45898ed5c736dde0791c7886acf65942f1 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 2 Sep 2013 18:29:24 +0900 Subject: [PATCH 011/153] Added member fucntion version of msgpack::type::tuple::get(). Added support functions for msgpack::type::tuple as same as std::tuple. --- cpp11/tuple.hpp | 81 ++++++++++++++++++++++++++++ src/msgpack/cpp_config.hpp | 13 ----- test/Makefile.am | 3 ++ test/msgpack_tuple.cc | 106 +++++++++++++++++++++++++++++++++++++ 4 files changed, 190 insertions(+), 13 deletions(-) create mode 100644 test/msgpack_tuple.cc diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index 1a92e208..30f9f54f 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -18,11 +18,92 @@ #ifndef MSGPACK_TYPE_TUPLE_HPP #define MSGPACK_TYPE_TUPLE_HPP +#include + #include "msgpack/object.hpp" #include "msgpack/cpp_config.hpp" namespace msgpack { +namespace type { + // tuple + using std::get; + using std::tuple_size; + using std::tuple_element; + using std::uses_allocator; + using std::ignore; + + template< class... Types > + class tuple : public std::tuple { + public: + using std::tuple::tuple; + + template< std::size_t I> + typename tuple_element >::type& + get() { return std::get(*this); } + + template< std::size_t I> + typename tuple_element >::type const& + get() const { return std::get(*this); } + + template< std::size_t I> + typename tuple_element >::type&& + get() && { return std::get(*this); } + }; + + template< class... Types > + tuple make_tuple( Types&&... args ) { + return tuple(std::forward(args)...); + } + + template< class... Types > + tuple make_tuple( std::tuple&& arg ) { + return tuple(std::forward&&>(arg)); + } + + template< class... Types > + tuple tie( Types&... args ) { + return std::tie(args...); + } + + template< class... Types > + tuple forward_as_tuple( Types&&... args ) { + return std::forward_as_tuple(std::forward(args)...); + } + + namespace detail { + template < typename... Types > + std::tuple&& get_std_tuple(tuple&& t) { + return std::forward&&>(t); + } + template < typename... Types > + std::tuple& get_std_tuple(tuple& t) { + return t; + } + template < typename... Types > + std::tuple const& get_std_tuple(tuple const& t) { + return t; + } + template < typename T > + T&& get_std_tuple(T&& t) { + return t; + } + } + template< class... Tuples > + auto tuple_cat(Tuples&&... args) -> + decltype( + msgpack::type::make_tuple(std::tuple_cat(detail::get_std_tuple(std::forward(args))...)) + ) { + return std::tuple_cat(detail::get_std_tuple(std::forward(args))...); + } + + template< class... Types > + void swap( tuple& lhs, tuple& rhs ) { + lhs.swap(rhs); + } + +} // namespace type + // --- Pack ( from tuple to packer stream --- template struct Packer { diff --git a/src/msgpack/cpp_config.hpp b/src/msgpack/cpp_config.hpp index 9c1dbb0c..b80573a5 100644 --- a/src/msgpack/cpp_config.hpp +++ b/src/msgpack/cpp_config.hpp @@ -63,19 +63,6 @@ namespace msgpack { using std::move; using std::swap; - namespace type { - // tuple - using std::tuple; - using std::get; - using std::make_tuple; - using std::tie; - using std::forward_as_tuple; - using std::tuple_cat; - using std::tuple_size; - using std::tuple_element; - using std::uses_allocator; - using std::ignore; - } } // msgpack diff --git a/test/Makefile.am b/test/Makefile.am index 1939f25c..08efc428 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -16,6 +16,7 @@ check_PROGRAMS = \ fixint \ fixint_c \ version \ + msgpack_tuple \ msgpackc_test \ msgpack_test @@ -46,6 +47,8 @@ fixint_c_SOURCES = fixint_c.cc version_SOURCES = version.cc +msgpack_tuple_SOURCES = msgpack_tuple.cc + msgpackc_test_SOURCES = msgpackc_test.cpp msgpack_test_SOURCES = msgpack_test.cpp diff --git a/test/msgpack_tuple.cc b/test/msgpack_tuple.cc new file mode 100644 index 00000000..57364f97 --- /dev/null +++ b/test/msgpack_tuple.cc @@ -0,0 +1,106 @@ +#include +#include + + +TEST(msgpack_tuple, member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} + +TEST(msgpack_tuple, non_member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, msgpack::type::get<0>(t1)); + EXPECT_EQ(true, msgpack::type::get<1>(t1)); + EXPECT_EQ("ABC", msgpack::type::get<2>(t1)); + msgpack::type::get<0>(t1) = 40; + msgpack::type::get<1>(t1) = false; + msgpack::type::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, msgpack::type::get<0>(t1)); + EXPECT_EQ(false, msgpack::type::get<1>(t1)); + EXPECT_EQ("DEFG", msgpack::type::get<2>(t1)); +} + +TEST(msgpack_tuple, std_non_member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, std::get<0>(t1)); + EXPECT_EQ(true, std::get<1>(t1)); + EXPECT_EQ("ABC", std::get<2>(t1)); + std::get<0>(t1) = 40; + std::get<1>(t1) = false; + std::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, std::get<0>(t1)); + EXPECT_EQ(false, std::get<1>(t1)); + EXPECT_EQ("DEFG", std::get<2>(t1)); +} + +TEST(msgpack_tuple, make_tuple) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); + + msgpack::type::tuple t2 = + msgpack::type::make_tuple(std::make_tuple(42, true, "ABC")); + EXPECT_EQ(42, t2.get<0>()); + EXPECT_EQ(true, t2.get<1>()); + EXPECT_EQ("ABC", t2.get<2>()); + +} + +TEST(msgpack_tuple, tie) +{ + int i(42); + bool b(true); + std::string s("ABC"); + msgpack::type::tuple t1 = msgpack::type::tie(i, b, s); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} + +TEST(msgpack_tuple, tuple_cat) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42); + msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); + msgpack::type::tuple t3 = msgpack::type::tuple_cat(t1, std::move(t2)); + EXPECT_EQ(42, t3.get<0>()); + EXPECT_EQ(true, t3.get<1>()); + EXPECT_EQ("ABC", t3.get<2>()); +} + +TEST(msgpack_tuple, swap) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + msgpack::type::tuple t2 = msgpack::type::make_tuple(40, false, "DEFG"); + msgpack::type::swap(t1, t2); + EXPECT_EQ(42, t2.get<0>()); + EXPECT_EQ(true, t2.get<1>()); + EXPECT_EQ("ABC", t2.get<2>()); + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} From e80cbd44378376e59252e2948c0e1e6561b12f53 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 2 Sep 2013 21:58:10 +0900 Subject: [PATCH 012/153] Tests for msgpack::type::tuple C++11 expansion moved to __cplusplus >= 201103. --- test/msgpack_tuple.cc | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/test/msgpack_tuple.cc b/test/msgpack_tuple.cc index 57364f97..b5a7e8f3 100644 --- a/test/msgpack_tuple.cc +++ b/test/msgpack_tuple.cc @@ -30,6 +30,7 @@ TEST(msgpack_tuple, non_member_get) EXPECT_EQ("DEFG", msgpack::type::get<2>(t1)); } +#if __cplusplus >= 201103 TEST(msgpack_tuple, std_non_member_get) { msgpack::type::tuple t1(42, true, "ABC"); @@ -56,13 +57,15 @@ TEST(msgpack_tuple, make_tuple) EXPECT_EQ(40, t1.get<0>()); EXPECT_EQ(false, t1.get<1>()); EXPECT_EQ("DEFG", t1.get<2>()); +} - msgpack::type::tuple t2 = +TEST(msgpack_tuple, std_make_tuple) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(std::make_tuple(42, true, "ABC")); - EXPECT_EQ(42, t2.get<0>()); - EXPECT_EQ(true, t2.get<1>()); - EXPECT_EQ("ABC", t2.get<2>()); - + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); } TEST(msgpack_tuple, tie) @@ -104,3 +107,4 @@ TEST(msgpack_tuple, swap) EXPECT_EQ(false, t1.get<1>()); EXPECT_EQ("DEFG", t1.get<2>()); } +#endif From f8561fbfd5548075c0c4a6c4e8835a664bf21866 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 3 Sep 2013 15:34:22 +0900 Subject: [PATCH 013/153] Added map packing speed test. --- example/speed_test.cc | 47 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 example/speed_test.cc diff --git a/example/speed_test.cc b/example/speed_test.cc new file mode 100644 index 00000000..1f7858a8 --- /dev/null +++ b/example/speed_test.cc @@ -0,0 +1,47 @@ +#include +#include +#include +#include +#include +#include + +void test_map_pack_unpack() { + std::cout << "[TEST][map_pack_unpack]" << std::endl; + // setup + std::cout << "Setting up map data..." << std::endl; + std::map m1; + int const num = 30000000L; + for (int i = 0; i < num; ++i) m1[i] = i; + std::cout << "Start packing..." << std::endl; + std::stringstream buffer; + { + boost::timer::cpu_timer timer; + msgpack::pack(buffer, m1); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Pack finished..." << std::endl; + + buffer.seekg(0); + std::string str(buffer.str()); + + // deserialized object is valid during the msgpack::zone instance alive. + msgpack::zone mempool; + msgpack::object deserialized; + std::cout << "Start unpacking..." << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; +} + + + +int main(void) +{ + test_map_pack_unpack(); +} + From 56b0ad680968e1e0b5e26007e45b9b3c77ca709b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 11:21:46 +0900 Subject: [PATCH 014/153] Modified passed by value of object to const reference of object. Modified object pointers to object references. This modification has increased unpack speed. --- example/speed_test.cc | 2 +- src/msgpack/unpack.hpp | 176 ++++++++++++++++++++--------------------- test/msgpack_test.cpp | 50 ++++++------ test/object.cc | 4 +- test/pack_unpack.cc | 8 +- 5 files changed, 120 insertions(+), 120 deletions(-) diff --git a/example/speed_test.cc b/example/speed_test.cc index 1f7858a8..570cb1bf 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -31,7 +31,7 @@ void test_map_pack_unpack() { std::cout << "Start unpacking..." << std::endl; { boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + msgpack::unpack(str.data(), str.size(), NULL, &mempool, deserialized); std::string result = timer.format(); std::cout << result << std::endl; } diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 1ad7f5a7..dc136800 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -62,83 +62,83 @@ private: static inline object template_callback_root(unpack_user* u) { object o; return o; } -static inline int template_callback_uint8(unpack_user* u, uint8_t d, object* o) -{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +inline int template_callback_uint8(unpack_user* u, uint8_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -static inline int template_callback_uint16(unpack_user* u, uint16_t d, object* o) -{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +inline int template_callback_uint16(unpack_user* u, uint16_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -static inline int template_callback_uint32(unpack_user* u, uint32_t d, object* o) -{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +inline int template_callback_uint32(unpack_user* u, uint32_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -static inline int template_callback_uint64(unpack_user* u, uint64_t d, object* o) -{ o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } +inline int template_callback_uint64(unpack_user* u, uint64_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -static inline int template_callback_int8(unpack_user* u, int8_t d, object* o) -{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +inline int template_callback_int8(unpack_user* u, int8_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -static inline int template_callback_int16(unpack_user* u, int16_t d, object* o) -{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +inline int template_callback_int16(unpack_user* u, int16_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -static inline int template_callback_int32(unpack_user* u, int32_t d, object* o) -{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +inline int template_callback_int32(unpack_user* u, int32_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -static inline int template_callback_int64(unpack_user* u, int64_t d, object* o) -{ if(d >= 0) { o->type = type::POSITIVE_INTEGER; o->via.u64 = d; return 0; } - else { o->type = type::NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +inline int template_callback_int64(unpack_user* u, int64_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -static inline int template_callback_float(unpack_user* u, float d, object* o) -{ o->type = type::DOUBLE; o->via.dec = d; return 0; } +inline int template_callback_float(unpack_user* u, float d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; return 0; } -static inline int template_callback_double(unpack_user* u, double d, object* o) -{ o->type = type::DOUBLE; o->via.dec = d; return 0; } +inline int template_callback_double(unpack_user* u, double d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; return 0; } -static inline int template_callback_nil(unpack_user* u, object* o) -{ o->type = type::NIL; return 0; } +inline int template_callback_nil(unpack_user* u, object& o) +{ o.type = type::NIL; return 0; } -static inline int template_callback_true(unpack_user* u, object* o) -{ o->type = type::BOOLEAN; o->via.boolean = true; return 0; } +inline int template_callback_true(unpack_user* u, object& o) +{ o.type = type::BOOLEAN; o.via.boolean = true; return 0; } -static inline int template_callback_false(unpack_user* u, object* o) -{ o->type = type::BOOLEAN; o->via.boolean = false; return 0; } +inline int template_callback_false(unpack_user* u, object& o) +{ o.type = type::BOOLEAN; o.via.boolean = false; return 0; } -static inline int template_callback_array(unpack_user* u, unsigned int n, object* o) +inline int template_callback_array(unpack_user* u, unsigned int n, object& o) { - o->type = type::ARRAY; - o->via.array.size = 0; - o->via.array.ptr = (object*)u->z()->malloc(n*sizeof(object)); - if(o->via.array.ptr == NULL) { return -1; } + o.type = type::ARRAY; + o.via.array.size = 0; + o.via.array.ptr = (object*)u->z()->malloc(n*sizeof(object)); + if(o.via.array.ptr == NULL) { return -1; } return 0; } -static inline int template_callback_array_item(unpack_user* u, object* c, object o) -{ c->via.array.ptr[c->via.array.size++] = o; return 0; } +inline int template_callback_array_item(unpack_user* u, object& c, object const& o) +{ c.via.array.ptr[c.via.array.size++] = o; return 0; } -static inline int template_callback_map(unpack_user* u, unsigned int n, object* o) +inline int template_callback_map(unpack_user* u, unsigned int n, object& o) { - o->type = type::MAP; - o->via.map.size = 0; - o->via.map.ptr = (object_kv*)u->z()->malloc(n*sizeof(object_kv)); - if(o->via.map.ptr == NULL) { return -1; } + o.type = type::MAP; + o.via.map.size = 0; + o.via.map.ptr = (object_kv*)u->z()->malloc(n*sizeof(object_kv)); + if(o.via.map.ptr == NULL) { return -1; } return 0; } -static inline int template_callback_map_item(unpack_user* u, object* c, object k, object v) +inline int template_callback_map_item(unpack_user* u, object& c, object const& k, object const& v) { - c->via.map.ptr[c->via.map.size].key = k; - c->via.map.ptr[c->via.map.size].val = v; - ++c->via.map.size; + c.via.map.ptr[c.via.map.size].key = k; + c.via.map.ptr[c.via.map.size].val = v; + ++c.via.map.size; return 0; } -static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, object* o) +inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, object& o) { - o->type = type::RAW; - o->via.raw.ptr = p; - o->via.raw.size = l; + o.type = type::RAW; + o.via.raw.ptr = p; + o.via.raw.size = l; u->set_referenced(true); return 0; } @@ -146,16 +146,16 @@ static inline int template_callback_raw(unpack_user* u, const char* b, const cha class template_unpack_stack { public: - object obj() const { return obj_; } + object const& obj() const { return obj_; } object& obj() { return obj_; } - void setObj(object obj) { obj_ = obj; } + void setObj(object const& obj) { obj_ = obj; } size_t count() const { return count_; } void set_count(size_t count) { count_ = count; } size_t decl_count() { return --count_; } unsigned int ct() const { return ct_; } void set_ct(unsigned int ct) { ct_ = ct; } - object map_key() const { return map_key_; } - void set_map_key(object map_key) { map_key_ = map_key; } + object const& map_key() const { return map_key_; } + void set_map_key(object const& map_key) { map_key_ = map_key; } private: object obj_; size_t count_; @@ -202,7 +202,7 @@ public: stack_[0].setObj(template_callback_root(&user_)); } - object data() const + object const& data() const { return stack_[0].obj(); } @@ -243,23 +243,23 @@ public: case CS_HEADER: if (0) { } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum - if(template_callback_uint8(user, *(uint8_t*)p, &obj) < 0) { goto _failed; } + if(template_callback_uint8(user, *(uint8_t*)p, obj) < 0) { goto _failed; } goto _push; } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum - if(template_callback_int8(user, *(int8_t*)p, &obj) < 0) { goto _failed; } + if(template_callback_int8(user, *(int8_t*)p, obj) < 0) { goto _failed; } goto _push; } else if(0xc0 <= *p && *p <= 0xdf) { // Variable switch(*p) { case 0xc0: // nil - if(template_callback_nil(user, &obj) < 0) { goto _failed; } + if(template_callback_nil(user, obj) < 0) { goto _failed; } goto _push; //case 0xc1: // string // again_terminal_trail(next_cs(p), p+1); case 0xc2: // false - if(template_callback_false(user, &obj) < 0) { goto _failed; } + if(template_callback_false(user, obj) < 0) { goto _failed; } goto _push; case 0xc3: // true - if(template_callback_true(user, &obj) < 0) { goto _failed; } + if(template_callback_true(user, obj) < 0) { goto _failed; } goto _push; case 0xc4: // bin 8 case 0xc5: // bin 16 @@ -313,7 +313,7 @@ public: } else if(0x90 <= *p && *p <= 0x9f) { // FixArray if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, ((unsigned int)*p) & 0x0f, &stack[top].obj()) < 0) { goto _failed; } + if(template_callback_array(user, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(((unsigned int)*p) & 0x0f); @@ -322,7 +322,7 @@ public: } else if(0x80 <= *p && *p <= 0x8f) { // FixMap if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, ((unsigned int)*p) & 0x0f, &stack[top].obj()) < 0) { goto _failed; } + if(template_callback_map(user, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(((unsigned int)*p) & 0x0f); @@ -347,7 +347,7 @@ _fixed_trail_again: case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = _msgpack_load32(uint32_t,n); - if(template_callback_float(user, mem.f, &obj) < 0) { goto _failed; } + if(template_callback_float(user, mem.f, obj) < 0) { goto _failed; } goto _push; } case CS_DOUBLE: { union { uint64_t i; double f; } mem; @@ -356,32 +356,32 @@ _fixed_trail_again: // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - if(template_callback_double(user, mem.f, &obj) < 0) { goto _failed; } + if(template_callback_double(user, mem.f, obj) < 0) { goto _failed; } goto _push; } case CS_UINT_8: - if(template_callback_uint8(user, *(uint8_t*)n, &obj) < 0) { goto _failed; } + if(template_callback_uint8(user, *(uint8_t*)n, obj) < 0) { goto _failed; } goto _push; case CS_UINT_16: - if(template_callback_uint16(user, _msgpack_load16(uint16_t,n), &obj) < 0) { goto _failed; } + if(template_callback_uint16(user, _msgpack_load16(uint16_t,n), obj) < 0) { goto _failed; } goto _push; case CS_UINT_32: - if(template_callback_uint32(user, _msgpack_load32(uint32_t,n), &obj) < 0) { goto _failed; } + if(template_callback_uint32(user, _msgpack_load32(uint32_t,n), obj) < 0) { goto _failed; } goto _push; case CS_UINT_64: - if(template_callback_uint64(user, _msgpack_load64(uint64_t,n), &obj) < 0) { goto _failed; } + if(template_callback_uint64(user, _msgpack_load64(uint64_t,n), obj) < 0) { goto _failed; } goto _push; case CS_INT_8: - if(template_callback_int8(user, *(int8_t*)n, &obj) < 0) { goto _failed; } + if(template_callback_int8(user, *(int8_t*)n, obj) < 0) { goto _failed; } goto _push; case CS_INT_16: - if(template_callback_int16(user, _msgpack_load16(int16_t,n), &obj) < 0) { goto _failed; } + if(template_callback_int16(user, _msgpack_load16(int16_t,n), obj) < 0) { goto _failed; } goto _push; case CS_INT_32: - if(template_callback_int32(user, _msgpack_load32(int32_t,n), &obj) < 0) { goto _failed; } + if(template_callback_int32(user, _msgpack_load32(int32_t,n), obj) < 0) { goto _failed; } goto _push; case CS_INT_64: - if(template_callback_int64(user, _msgpack_load64(int64_t,n), &obj) < 0) { goto _failed; } + if(template_callback_int64(user, _msgpack_load64(int64_t,n), obj) < 0) { goto _failed; } goto _push; case CS_BIN_8: @@ -404,11 +404,11 @@ _fixed_trail_again: goto _fixed_trail_again; case ACS_RAW_VALUE: _raw_zero: - if(template_callback_raw(user, (const char*)data, (const char*)n, trail, &obj) < 0) { goto _failed; } + if(template_callback_raw(user, (const char*)data, (const char*)n, trail, obj) < 0) { goto _failed; } goto _push; case CS_ARRAY_16: if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, _msgpack_load16(uint16_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(template_callback_array(user, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(_msgpack_load16(uint16_t, n)); @@ -417,7 +417,7 @@ _raw_zero: case CS_ARRAY_32: /* FIXME security guard */ if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, _msgpack_load32(uint32_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(template_callback_array(user, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(_msgpack_load32(uint32_t, n)); @@ -426,7 +426,7 @@ _raw_zero: case CS_MAP_16: if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, _msgpack_load16(uint16_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(template_callback_map(user, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(_msgpack_load16(uint16_t, n)); @@ -435,7 +435,7 @@ _raw_zero: case CS_MAP_32: /* FIXME security guard */ if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, _msgpack_load32(uint32_t, n), &stack[top].obj()) < 0) { goto _failed; } + if(template_callback_map(user, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(_msgpack_load32(uint32_t, n)); @@ -452,7 +452,7 @@ _push: c = &stack[top-1]; switch(c->ct()) { case CT_ARRAY_ITEM: - if(template_callback_array_item(user, &c->obj(), obj) < 0) { goto _failed; } + if(template_callback_array_item(user, c->obj(), obj) < 0) { goto _failed; } if(c->decl_count() == 0) { obj = c->obj(); --top; @@ -465,7 +465,7 @@ _push: c->set_ct(CT_MAP_VALUE); goto _header_again; case CT_MAP_VALUE: - if(template_callback_map_item(user, &c->obj(), c->map_key(), obj) < 0) { goto _failed; } + if(template_callback_map_item(user, c->obj(), c->map_key(), obj) < 0) { goto _failed; } if(c->decl_count() == 0) { obj = c->obj(); --top; @@ -539,7 +539,7 @@ class unpacked { public: unpacked() { } - unpacked(object obj, msgpack::unique_ptr z) : + unpacked(object const& obj, msgpack::unique_ptr z) : m_obj(obj), m_zone(msgpack::move(z)) { } object& get() @@ -622,7 +622,7 @@ public: bool execute(); /*! for backward compatibility */ - object data(); + object const& data(); /*! for backward compatibility */ zone* release_zone(); @@ -684,7 +684,7 @@ typedef enum { // obsolete static unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result); + zone* z, object& result); // obsolete @@ -858,7 +858,7 @@ inline int unpacker::execute_imp() return ret; } -inline object unpacker::data() +inline object const& unpacker::data() { return ctx_.data(); } @@ -943,7 +943,7 @@ namespace detail { inline unpack_return unpack_imp(const char* data, size_t len, size_t* off, - zone* result_zone, object* result) + zone* result_zone, object& result) { size_t noff = 0; if(off != NULL) { noff = *off; } @@ -970,7 +970,7 @@ unpack_imp(const char* data, size_t len, size_t* off, return UNPACK_CONTINUE; } - *result = ctx.data(); + result = ctx.data(); if(noff < len) { return UNPACK_EXTRA_BYTES; @@ -988,7 +988,7 @@ inline void unpack(unpacked* result, msgpack::unique_ptr z(new zone()); unpack_return ret = detail::unpack_imp( - data, len, offset, z.get(), &obj); + data, len, offset, z.get(), obj); switch(ret) { @@ -1014,7 +1014,7 @@ inline void unpack(unpacked* result, // obsolete inline unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result) + zone* z, object& result) { return detail::unpack_imp(data, len, off, z, result); @@ -1025,7 +1025,7 @@ inline object unpack(const char* data, size_t len, zone& z, size_t* off) { object result; - switch( unpack(data, len, off, &z, &result) ) { + switch( unpack(data, len, off, &z, result) ) { case UNPACK_SUCCESS: return result; diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index b14caae1..f00637d3 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,7 +38,7 @@ const double kEPS = 1e-10; msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ @@ -165,7 +165,7 @@ TEST(MSGPACK, simple_buffer_float) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float val2; obj.convert(&val2); @@ -255,7 +255,7 @@ TEST(MSGPACK, simple_buffer_double) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); double val2; obj.convert(&val2); @@ -277,7 +277,7 @@ TEST(MSGPACK, simple_buffer_true) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -292,7 +292,7 @@ TEST(MSGPACK, simple_buffer_false) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -314,7 +314,7 @@ TEST(MSGPACK_STL, simple_buffer_string) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); string val2; obj.convert(&val2); @@ -334,7 +334,7 @@ TEST(MSGPACK_STL, simple_buffer_vector) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); vector val2; obj.convert(&val2); @@ -354,7 +354,7 @@ TEST(MSGPACK_STL, simple_buffer_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); map val2; obj.convert(&val2); @@ -374,7 +374,7 @@ TEST(MSGPACK_STL, simple_buffer_deque) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); deque val2; obj.convert(&val2); @@ -394,7 +394,7 @@ TEST(MSGPACK_STL, simple_buffer_list) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); list val2; obj.convert(&val2); @@ -414,7 +414,7 @@ TEST(MSGPACK_STL, simple_buffer_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); set val2; obj.convert(&val2); @@ -432,7 +432,7 @@ TEST(MSGPACK_STL, simple_buffer_pair) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); pair val2; obj.convert(&val2); @@ -455,7 +455,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multimap val2; obj.convert(&val2); @@ -485,7 +485,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multiset val2; obj.convert(&val2); @@ -520,7 +520,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_map val2; obj.convert(&val2); @@ -547,7 +547,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multimap val2; obj.convert(&val2); @@ -581,7 +581,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_set val2; obj.convert(&val2); @@ -603,7 +603,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multiset val2; obj.convert(&val2); @@ -760,7 +760,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -793,7 +793,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass2 val2; val2.i = -1; @@ -815,7 +815,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -856,7 +856,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestEnumMemberClass val2; val2.t1 = TestEnumMemberClass::STATE_INVALID; @@ -919,7 +919,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -934,7 +934,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -962,7 +962,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ diff --git a/test/object.cc b/test/object.cc index 5390c4ae..71c1e59c 100644 --- a/test/object.cc +++ b/test/object.cc @@ -37,7 +37,7 @@ TEST(object, convert) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); myclass m2; @@ -58,7 +58,7 @@ TEST(object, as) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(m1, obj.as()); diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index ac47f2d9..19a20baf 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -60,7 +60,7 @@ TEST(unpack, myclass) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); @@ -105,17 +105,17 @@ TEST(unpack, sequence_compat) msgpack::object obj; msgpack::unpack_return ret; - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(1, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(2, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(3, obj.as()); From 8a08548f365660a17f41f14ee05c21f3201db15d Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 13:28:23 +0900 Subject: [PATCH 015/153] Modified passed by value of object to const reference of object. Removed C function call in operator==. --- cpp11/define.hpp | 12 ++-- cpp11/tuple.hpp | 6 +- src/msgpack/object.hpp | 102 +++++++++++++++++++++++++------- src/msgpack/type/define.hpp.erb | 8 +-- src/msgpack/type/tuple.hpp.erb | 8 +-- 5 files changed, 99 insertions(+), 37 deletions(-) diff --git a/cpp11/define.hpp b/cpp11/define.hpp index 526a4aea..9804aa1d 100644 --- a/cpp11/define.hpp +++ b/cpp11/define.hpp @@ -24,7 +24,7 @@ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ } \ - void msgpack_unpack(msgpack::object o) \ + void msgpack_unpack(msgpack::object const& o) \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ @@ -38,7 +38,7 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object o, enum& v) \ + inline enum& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ @@ -71,7 +71,7 @@ struct define_imp { define_imp::pack(pk, t); pk.pack(std::get(t)); } - static void unpack(msgpack::object o, Tuple& t) { + static void unpack(msgpack::object const& o, Tuple& t) { define_imp::unpack(o, t); const size_t size = o.via.array.size; if(size <= N-1) { return; } @@ -89,7 +89,7 @@ struct define_imp { static void pack(Packer& pk, Tuple const& t) { pk.pack(std::get<0>(t)); } - static void unpack(msgpack::object o, Tuple& t) { + static void unpack(msgpack::object const& o, Tuple& t) { const size_t size = o.via.array.size; if(size <= 0) { return; } o.via.array.ptr[0].convert(&std::get<0>(t)); @@ -112,7 +112,7 @@ struct define { define_imp, sizeof...(Args)>::pack(pk, a); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } @@ -139,7 +139,7 @@ struct define<> { { pk.pack_array(0); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } } diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index 30f9f54f..0ef661f5 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -138,7 +138,7 @@ const packer& operator<< ( template struct Converter { static void convert( - object o, + object const& o, Tuple& v) { Converter::convert(o, v); o.via.array.ptr[N-1].convert(v))>::type>(&type::get(v)); @@ -148,7 +148,7 @@ struct Converter { template struct Converter { static void convert ( - object o, + object const& o, Tuple& v) { o.via.array.ptr[0].convert(v))>::type>(&type::get<0>(v)); } @@ -156,7 +156,7 @@ struct Converter { template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); } diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 1f2de2b5..c80da41b 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -125,22 +125,22 @@ private: }; -bool operator==(const object x, const object y); -bool operator!=(const object x, const object y); +bool operator==(const object& x, const object& y); +bool operator!=(const object& x, const object& y); template -bool operator==(const object x, const T& y); +bool operator==(const object& x, const T& y); template -bool operator==(const T& y, const object x); +bool operator==(const T& y, const object& x); template -bool operator!=(const object x, const T& y); +bool operator!=(const object& x, const T& y); template -bool operator!=(const T& y, const object x); +bool operator!=(const T& y, const object& x); -std::ostream& operator<< (std::ostream& s, const object o); +std::ostream& operator<< (std::ostream& s, const object& o); // serialize operator @@ -149,7 +149,7 @@ packer& operator<< (packer& o, const T& v); // convert operator template -T& operator>> (object o, T& v); +T& operator>> (object const& o, T& v); // deconvert operator template @@ -157,7 +157,7 @@ void operator<< (object::with_zone& o, const T& v); struct object::implicit_type { - implicit_type(object o) : obj(o) { } + implicit_type(object const& o) : obj(o) { } ~implicit_type() { } template @@ -184,7 +184,7 @@ public: o << static_cast(*this); } - void msgpack_unpack(object o) + void msgpack_unpack(object const& o) { o >> static_cast(*this); } @@ -199,14 +199,14 @@ inline packer& packer::pack(const T& v) return *this; } -inline object& operator>> (object o, object& v) +inline object& operator>> (object const& o, object& v) { v = o; return v; } template -inline T& operator>> (object o, T& v) +inline T& operator>> (object const& o, T& v) { v.msgpack_unpack(o.convert()); return v; @@ -235,20 +235,82 @@ void operator<< (object::with_zone& o, const T& v) } -inline bool operator==(const object x, const object y) +inline bool operator==(const object& x, const object& y) { - return msgpack_object_equal(x, y); + if(x.type != y.type) { return false; } + + switch(x.type) { + case type::NIL: + return true; + + case type::BOOLEAN: + return x.via.boolean == y.via.boolean; + + case type::POSITIVE_INTEGER: + return x.via.u64 == y.via.u64; + + case type::NEGATIVE_INTEGER: + return x.via.i64 == y.via.i64; + + case type::DOUBLE: + return x.via.dec == y.via.dec; + + case type::RAW: + return x.via.raw.size == y.via.raw.size && + memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0; + + case type::ARRAY: + if(x.via.array.size != y.via.array.size) { + return false; + } else if(x.via.array.size == 0) { + return true; + } else { + object* px = x.via.array.ptr; + object* const pxend = x.via.array.ptr + x.via.array.size; + object* py = y.via.array.ptr; + do { + if(!(*px == *py)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + case type::MAP: + if(x.via.map.size != y.via.map.size) { + return false; + } else if(x.via.map.size == 0) { + return true; + } else { + object_kv* px = x.via.map.ptr; + object_kv* const pxend = x.via.map.ptr + x.via.map.size; + object_kv* py = y.via.map.ptr; + do { + if(!(px->key == py->key) || !(px->val == py->val)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + default: + return false; + } } template -inline bool operator==(const object x, const T& y) +inline bool operator==(const object& x, const T& y) try { return x == object(y); } catch (msgpack::type_error&) { return false; } -inline bool operator!=(const object x, const object y) +inline bool operator!=(const object& x, const object& y) { return !(x == y); } template @@ -256,11 +318,11 @@ inline bool operator==(const T& y, const object x) { return x == y; } template -inline bool operator!=(const object x, const T& y) +inline bool operator!=(const object& x, const T& y) { return !(x == y); } template -inline bool operator!=(const T& y, const object x) +inline bool operator!=(const T& y, const object& x) { return x != y; } @@ -335,7 +397,7 @@ inline object::operator msgpack_object() const // obsolete template -inline void convert(T& v, object o) +inline void convert(T& v, object const& o) { o.convert(&v); } @@ -412,7 +474,7 @@ packer& operator<< (packer& o, const object& v) } } -std::ostream& operator<< (std::ostream& s, const object o) +std::ostream& operator<< (std::ostream& s, const object& o) { switch(o.type) { case type::NIL: diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb index 8aead021..905b4496 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/src/msgpack/type/define.hpp.erb @@ -24,7 +24,7 @@ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ } \ - void msgpack_unpack(msgpack::object o) \ + void msgpack_unpack(msgpack::object const& o) \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ @@ -38,7 +38,7 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object o, enum& v) \ + inline enum& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ @@ -78,7 +78,7 @@ struct define<> { { pk.pack_array(0); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } } @@ -103,7 +103,7 @@ struct define, A<%=j%><%}%>> { <%0.upto(i) {|j|%> pk.pack(a<%=j%>);<%}%> } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index 4f73eb20..cc0f1ea9 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -92,7 +92,7 @@ private: template <> struct tuple<> { tuple() {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(this); } typedef tuple<> value_type; }; <%0.upto(GENERATION_LIMIT) {|i|%> @@ -102,7 +102,7 @@ struct tuple, A<%=j%><%}%>> { tuple() {} tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -134,7 +134,7 @@ tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::tr } // namespace type inline type::tuple<>& operator>> ( - object o, + object const& o, type::tuple<>& v) { if(o.type != type::ARRAY) { throw type_error(); } return v; @@ -142,7 +142,7 @@ inline type::tuple<>& operator>> ( <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> type::tuple, A<%=j%><%}%>>& operator>> ( - object o, + object const& o, type::tuple, A<%=j%><%}%>>& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < <%=i+1%>) { throw type_error(); } From 7593e5ce0e3b59d77f065b59d9fb83478a78429a Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 14:04:49 +0900 Subject: [PATCH 016/153] Removed object copy in implicit conversion class. Removed redundant function prototype declaration. Adjusted tab position. --- src/msgpack/object.hpp | 45 ++++++++---------------------------------- 1 file changed, 8 insertions(+), 37 deletions(-) diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index c80da41b..6042d6c6 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -35,14 +35,14 @@ class type_error : public std::bad_cast { }; namespace type { enum object_type { - NIL = MSGPACK_OBJECT_NIL, - BOOLEAN = MSGPACK_OBJECT_BOOLEAN, + NIL = MSGPACK_OBJECT_NIL, + BOOLEAN = MSGPACK_OBJECT_BOOLEAN, POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, DOUBLE = MSGPACK_OBJECT_DOUBLE, - RAW = MSGPACK_OBJECT_RAW, + RAW = MSGPACK_OBJECT_RAW, ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP, + MAP = MSGPACK_OBJECT_MAP, }; } @@ -124,38 +124,6 @@ private: with_zone(); }; - -bool operator==(const object& x, const object& y); -bool operator!=(const object& x, const object& y); - -template -bool operator==(const object& x, const T& y); - -template -bool operator==(const T& y, const object& x); - -template -bool operator!=(const object& x, const T& y); - -template -bool operator!=(const T& y, const object& x); - -std::ostream& operator<< (std::ostream& s, const object& o); - - -// serialize operator -template -packer& operator<< (packer& o, const T& v); - -// convert operator -template -T& operator>> (object const& o, T& v); - -// deconvert operator -template -void operator<< (object::with_zone& o, const T& v); - - struct object::implicit_type { implicit_type(object const& o) : obj(o) { } ~implicit_type() { } @@ -164,7 +132,7 @@ struct object::implicit_type { operator T() { return obj.as(); } private: - object obj; + object const& obj; }; @@ -205,6 +173,7 @@ inline object& operator>> (object const& o, object& v) return v; } +// convert operator template inline T& operator>> (object const& o, T& v) { @@ -222,12 +191,14 @@ struct packer_serializer { }; } +// serialize operator template inline packer& operator<< (packer& o, const T& v) { return detail::packer_serializer::pack(o, v); } +// deconvert operator template void operator<< (object::with_zone& o, const T& v) { From 72b3064a67407380abeaa75e1bfd13eb0829b2d9 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 14:47:38 +0900 Subject: [PATCH 017/153] Removed redundant try-catch, zone's constructor never throw. In the C++11 version, added noexcept. In the C++03 version, added throw() as comments because actual throw() introduces some overhead. Untabified. --- cpp11/zone.hpp | 12 +- src/msgpack/zone.hpp.erb | 391 +++++++++++++++++++-------------------- 2 files changed, 195 insertions(+), 208 deletions(-) diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index 17a4e0dd..b7fbf5b4 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -149,7 +149,7 @@ private: finalizer_array finalizer_array_; public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; public: static zone* create(size_t chunk_size); @@ -185,13 +185,7 @@ inline zone* zone::create(size_t chunk_size) if (!z) { return nullptr; } - try { - new (z) zone(chunk_size); - } - catch (...) { - ::free(z); - return nullptr; - } + new (z) zone(chunk_size); return z; } @@ -201,7 +195,7 @@ inline void zone::destroy(zone* z) ::free(z); } -inline zone::zone(size_t chunk_size):chunk_size_(chunk_size), chunk_list_(chunk_size_) +inline zone::zone(size_t chunk_size) noexcept:chunk_size_(chunk_size), chunk_list_(chunk_size_) { } diff --git a/src/msgpack/zone.hpp.erb b/src/msgpack/zone.hpp.erb index 11e0fd18..6c2ab0ab 100644 --- a/src/msgpack/zone.hpp.erb +++ b/src/msgpack/zone.hpp.erb @@ -3,17 +3,17 @@ // // Copyright (C) 2008-2010 FURUHASHI Sadayuki // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at // -// http://www.apache.org/licenses/LICENSE-2.0 +// http://www.apache.org/licenses/LICENSE-2.0 // -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. // #ifndef MSGPACK_ZONE_HPP #define MSGPACK_ZONE_HPP @@ -36,275 +36,268 @@ namespace msgpack { class zone { - struct finalizer { - finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} - void operator()() { func_(data_); } - void (*func_)(void*); - void* data_; - }; - struct finalizer_array { - finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} - void call() { - finalizer* fin = tail_; - for(; fin != array_; --fin) (*(fin-1))(); - } - ~finalizer_array() { - call(); - ::free(array_); - } - void clear() { - call(); - tail_ = array_; - } - void push(void (*func)(void* data), void* data) - { - finalizer* fin = tail_; - - if(fin == end_) { - push_expand(func, data); - return; - } - - fin->func_ = func; - fin->data_ = data; - - ++tail_; - } - void push_expand(void (*func)(void*), void* data) { - const size_t nused = end_ - array_; - size_t nnext; - if(nused == 0) { - nnext = (sizeof(finalizer) < 72/2) ? - 72 / sizeof(finalizer) : 8; - } else { - nnext = nused * 2; - } - finalizer* tmp = - static_cast(::realloc(array_, sizeof(finalizer) * nnext)); - if(!tmp) { - throw std::bad_alloc(); - } - array_ = tmp; - end_ = tmp + nnext; - tail_ = tmp + nused; - new (tail_) finalizer(func, data); + struct finalizer { + finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} + void operator()() { func_(data_); } + void (*func_)(void*); + void* data_; + }; + struct finalizer_array { + finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} + void call() { + finalizer* fin = tail_; + for(; fin != array_; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(array_); + } + void clear() { + call(); + tail_ = array_; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = tail_; - ++tail_; - } - finalizer* tail_; - finalizer* end_; - finalizer* array_; - }; - struct chunk { - chunk* next_; - }; - struct chunk_list { - chunk_list(size_t chunk_size) - { - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - throw std::bad_alloc(); - } - - head_ = c; - free_ = chunk_size; - ptr_ = reinterpret_cast(c) + sizeof(chunk); - c->next_ = nullptr; - } - ~chunk_list() - { - chunk* c = head_; - while(true) { - chunk* n = c->next_; - ::free(c); - if(n) { - c = n; - } else { - break; - } - } - } - void clear(size_t chunk_size) - { - chunk* c = head_; - while(true) { - chunk* n = c->next_; - if(n) { - ::free(c); - c = n; - } else { - break; - } - } - head_->next_ = nullptr; - free_ = chunk_size; - ptr_ = reinterpret_cast(head_) + sizeof(chunk); - } - size_t free_; - char* ptr_; - chunk* head_; - }; - size_t chunk_size_; - chunk_list chunk_list_; - finalizer_array finalizer_array_; - -public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); + if(fin == end_) { + push_expand(func, data); + return; + } + + fin->func_ = func; + fin->data_ = data; + + ++tail_; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = end_ - array_; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(array_, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + array_ = tmp; + end_ = tmp + nnext; + tail_ = tmp + nused; + new (tail_) finalizer(func, data); + + ++tail_; + } + finalizer* tail_; + finalizer* end_; + finalizer* array_; + }; + struct chunk { + chunk* next_; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } + + head_ = c; + free_ = chunk_size; + ptr_ = reinterpret_cast(c) + sizeof(chunk); + c->next_ = nullptr; + } + ~chunk_list() + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + ::free(c); + if(n) { + c = n; + } else { + break; + } + } + } + void clear(size_t chunk_size) + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + head_->next_ = nullptr; + free_ = chunk_size; + ptr_ = reinterpret_cast(head_) + sizeof(chunk); + } + size_t free_; + char* ptr_; + chunk* head_; + }; + size_t chunk_size_; + chunk_list chunk_list_; + finalizer_array finalizer_array_; public: - static zone* create(size_t chunk_size); - static void destroy(zone* zone); - void* malloc(size_t size); - void* malloc_no_align(size_t size); + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; - void push_finalizer(void (*func)(void*), void* data); +public: + static zone* create(size_t chunk_size); + static void destroy(zone* zone); + void* malloc(size_t size); + void* malloc_no_align(size_t size); - template - void push_finalizer(msgpack::unique_ptr obj); + void push_finalizer(void (*func)(void*), void* data); - void clear(); + template + void push_finalizer(msgpack::unique_ptr obj); - void swap(zone& o); + void clear(); - <%0.upto(GENERATION_LIMIT) {|i|%> - template , typename A<%=j%><%}%>> - T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); - <%}%> + void swap(zone& o); + + <%0.upto(GENERATION_LIMIT) {|i|%> + template , typename A<%=j%><%}%>> + T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); + <%}%> private: - void undo_malloc(size_t size); + void undo_malloc(size_t size); - template - static void object_destructor(void* obj); + template + static void object_destructor(void* obj); - void* malloc_expand(size_t size); + void* malloc_expand(size_t size); }; inline zone* zone::create(size_t chunk_size) { - zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); - if (!z) { - return nullptr; - } - try { - new (z) zone(chunk_size); - } - catch (...) { - ::free(z); - return nullptr; - } - return z; + zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); + if (!z) { + return nullptr; + } + new (z) zone(chunk_size); + return z; } inline void zone::destroy(zone* z) { - z->~zone(); - ::free(z); + z->~zone(); + ::free(z); } -inline zone::zone(size_t chunk_size):chunk_size_(chunk_size), chunk_list_(chunk_size_) +inline zone::zone(size_t chunk_size) /* throw() */ :chunk_size_(chunk_size), chunk_list_(chunk_size_) { } inline void* zone::malloc(size_t size) { - return malloc_no_align( - ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); + return malloc_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } inline void* zone::malloc_no_align(size_t size) { - if(chunk_list_.free_ < size) { - return malloc_expand(size); - } + if(chunk_list_.free_ < size) { + return malloc_expand(size); + } - char* ptr = chunk_list_.ptr_; - chunk_list_.free_ -= size; - chunk_list_.ptr_ += size; + char* ptr = chunk_list_.ptr_; + chunk_list_.free_ -= size; + chunk_list_.ptr_ += size; - return ptr; + return ptr; } inline void* zone::malloc_expand(size_t size) { - chunk_list* const cl = &chunk_list_; + chunk_list* const cl = &chunk_list_; - size_t sz = chunk_size_; + size_t sz = chunk_size_; - while(sz < size) { - sz *= 2; - } + while(sz < size) { + sz *= 2; + } - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - char* ptr = reinterpret_cast(c) + sizeof(chunk); + char* ptr = reinterpret_cast(c) + sizeof(chunk); - c->next_ = cl->head_; - cl->head_ = c; - cl->free_ = sz - size; - cl->ptr_ = ptr + size; + c->next_ = cl->head_; + cl->head_ = c; + cl->free_ = sz - size; + cl->ptr_ = ptr + size; - return ptr; + return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - finalizer_array_.push(func, data); + finalizer_array_.push(func, data); } template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - finalizer_array_.push(&zone::object_destructor, obj.get()); - obj.release(); + finalizer_array_.push(&zone::object_destructor, obj.get()); + obj.release(); } inline void zone::clear() { - finalizer_array_.clear(); - chunk_list_.clear(chunk_size_); + finalizer_array_.clear(); + chunk_list_.clear(chunk_size_); } inline void zone::swap(zone& o) { - std::swap(*this, o); + std::swap(*this, o); } template void zone::object_destructor(void* obj) { - reinterpret_cast(obj)->~T(); + reinterpret_cast(obj)->~T(); } inline void zone::undo_malloc(size_t size) { - chunk_list_.ptr_ -= size; - chunk_list_.free_ += size; + chunk_list_.ptr_ -= size; + chunk_list_.free_ += size; } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) { - void* x = malloc(sizeof(T)); - try { - finalizer_array_.push(&zone::object_destructor, x); - } catch (...) { - undo_malloc(sizeof(T)); - throw; - } - try { - return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); - } catch (...) { - --finalizer_array_.tail_; - undo_malloc(sizeof(T)); - throw; - } + void* x = malloc(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_malloc(sizeof(T)); + throw; + } + try { + return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); + } catch (...) { + --finalizer_array_.tail_; + undo_malloc(sizeof(T)); + throw; + } } <%}%> } // namespace msgpack #endif /* msgpack/zone.hpp */ - From bad3801eaea5f699f7fdd5c12c070e9c33b1a0bc Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 16:00:36 +0900 Subject: [PATCH 018/153] Modified zone* to zone&. --- example/speed_test.cc | 2 +- src/msgpack/unpack.hpp | 23 +++++++++---------- test/msgpack_test.cpp | 50 +++++++++++++++++++++--------------------- test/object.cc | 4 ++-- test/pack_unpack.cc | 8 +++---- 5 files changed, 44 insertions(+), 43 deletions(-) diff --git a/example/speed_test.cc b/example/speed_test.cc index 570cb1bf..267c042b 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -31,7 +31,7 @@ void test_map_pack_unpack() { std::cout << "Start unpacking..." << std::endl; { boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, deserialized); + msgpack::unpack(str.data(), str.size(), NULL, mempool, deserialized); std::string result = timer.format(); std::cout << result << std::endl; } diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index dc136800..11bcbd06 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -50,8 +50,9 @@ namespace detail { class unpack_user { public: - zone* z() const { return z_; } - void set_z(zone* z) { z_ = z; } + zone const& z() const { return *z_; } + zone& z() { return *z_; } + void set_z(zone& z) { z_ = &z; } bool referenced() const { return referenced_; } void set_referenced(bool referenced) { referenced_ = referenced; } private: @@ -109,7 +110,7 @@ inline int template_callback_array(unpack_user* u, unsigned int n, object& o) { o.type = type::ARRAY; o.via.array.size = 0; - o.via.array.ptr = (object*)u->z()->malloc(n*sizeof(object)); + o.via.array.ptr = (object*)u->z().malloc(n*sizeof(object)); if(o.via.array.ptr == NULL) { return -1; } return 0; } @@ -121,7 +122,7 @@ inline int template_callback_map(unpack_user* u, unsigned int n, object& o) { o.type = type::MAP; o.via.map.size = 0; - o.via.map.ptr = (object_kv*)u->z()->malloc(n*sizeof(object_kv)); + o.via.map.ptr = (object_kv*)u->z().malloc(n*sizeof(object_kv)); if(o.via.map.ptr == NULL) { return -1; } return 0; } @@ -684,7 +685,7 @@ typedef enum { // obsolete static unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object& result); + zone& z, object& result); // obsolete @@ -719,7 +720,7 @@ inline unpacker::unpacker(size_t initial_buffer_size) detail::init_count(buffer_); ctx_.init(); - ctx_.user().set_z(z_); + ctx_.user().set_z(*z_); ctx_.user().set_referenced(false); } @@ -876,7 +877,7 @@ inline zone* unpacker::release_zone() zone* old = z_; z_ = r; - ctx_.user().set_z(z_); + ctx_.user().set_z(*z_); return old; } @@ -943,7 +944,7 @@ namespace detail { inline unpack_return unpack_imp(const char* data, size_t len, size_t* off, - zone* result_zone, object& result) + zone& result_zone, object& result) { size_t noff = 0; if(off != NULL) { noff = *off; } @@ -988,7 +989,7 @@ inline void unpack(unpacked* result, msgpack::unique_ptr z(new zone()); unpack_return ret = detail::unpack_imp( - data, len, offset, z.get(), obj); + data, len, offset, *z, obj); switch(ret) { @@ -1014,7 +1015,7 @@ inline void unpack(unpacked* result, // obsolete inline unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object& result) + zone& z, object& result) { return detail::unpack_imp(data, len, off, z, result); @@ -1025,7 +1026,7 @@ inline object unpack(const char* data, size_t len, zone& z, size_t* off) { object result; - switch( unpack(data, len, off, &z, result) ) { + switch( unpack(data, len, off, z, result) ) { case UNPACK_SUCCESS: return result; diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index f00637d3..5e23e51c 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,7 +38,7 @@ const double kEPS = 1e-10; msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ @@ -165,7 +165,7 @@ TEST(MSGPACK, simple_buffer_float) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float val2; obj.convert(&val2); @@ -255,7 +255,7 @@ TEST(MSGPACK, simple_buffer_double) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); double val2; obj.convert(&val2); @@ -277,7 +277,7 @@ TEST(MSGPACK, simple_buffer_true) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -292,7 +292,7 @@ TEST(MSGPACK, simple_buffer_false) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -314,7 +314,7 @@ TEST(MSGPACK_STL, simple_buffer_string) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); string val2; obj.convert(&val2); @@ -334,7 +334,7 @@ TEST(MSGPACK_STL, simple_buffer_vector) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); vector val2; obj.convert(&val2); @@ -354,7 +354,7 @@ TEST(MSGPACK_STL, simple_buffer_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); map val2; obj.convert(&val2); @@ -374,7 +374,7 @@ TEST(MSGPACK_STL, simple_buffer_deque) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); deque val2; obj.convert(&val2); @@ -394,7 +394,7 @@ TEST(MSGPACK_STL, simple_buffer_list) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); list val2; obj.convert(&val2); @@ -414,7 +414,7 @@ TEST(MSGPACK_STL, simple_buffer_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); set val2; obj.convert(&val2); @@ -432,7 +432,7 @@ TEST(MSGPACK_STL, simple_buffer_pair) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); pair val2; obj.convert(&val2); @@ -455,7 +455,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multimap val2; obj.convert(&val2); @@ -485,7 +485,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multiset val2; obj.convert(&val2); @@ -520,7 +520,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_map val2; obj.convert(&val2); @@ -547,7 +547,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multimap val2; obj.convert(&val2); @@ -581,7 +581,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_set val2; obj.convert(&val2); @@ -603,7 +603,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multiset val2; obj.convert(&val2); @@ -760,7 +760,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -793,7 +793,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass2 val2; val2.i = -1; @@ -815,7 +815,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -856,7 +856,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestEnumMemberClass val2; val2.t1 = TestEnumMemberClass::STATE_INVALID; @@ -919,7 +919,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -934,7 +934,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -962,7 +962,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ diff --git a/test/object.cc b/test/object.cc index 71c1e59c..7a6b0a87 100644 --- a/test/object.cc +++ b/test/object.cc @@ -37,7 +37,7 @@ TEST(object, convert) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); myclass m2; @@ -58,7 +58,7 @@ TEST(object, as) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(m1, obj.as()); diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index 19a20baf..6718a01b 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -60,7 +60,7 @@ TEST(unpack, myclass) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); @@ -105,17 +105,17 @@ TEST(unpack, sequence_compat) msgpack::object obj; msgpack::unpack_return ret; - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(1, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(2, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(3, obj.as()); From 521a4f41904b2c1b9a0bab432ff1307ece1c0205 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 16:13:34 +0900 Subject: [PATCH 019/153] Modified unpack_user* to unpack_user&. Removed redundant 'static'. --- src/msgpack/unpack.hpp | 97 +++++++++++++++++++++--------------------- 1 file changed, 48 insertions(+), 49 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 11bcbd06..6b538760 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -60,74 +60,74 @@ private: bool referenced_; }; -static inline object template_callback_root(unpack_user* u) +inline object template_callback_root(unpack_user&) { object o; return o; } -inline int template_callback_uint8(unpack_user* u, uint8_t d, object& o) +inline int template_callback_uint8(unpack_user&, uint8_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -inline int template_callback_uint16(unpack_user* u, uint16_t d, object& o) +inline int template_callback_uint16(unpack_user&, uint16_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -inline int template_callback_uint32(unpack_user* u, uint32_t d, object& o) +inline int template_callback_uint32(unpack_user&, uint32_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -inline int template_callback_uint64(unpack_user* u, uint64_t d, object& o) +inline int template_callback_uint64(unpack_user&, uint64_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } -inline int template_callback_int8(unpack_user* u, int8_t d, object& o) +inline int template_callback_int8(unpack_user&, int8_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -inline int template_callback_int16(unpack_user* u, int16_t d, object& o) +inline int template_callback_int16(unpack_user&, int16_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -inline int template_callback_int32(unpack_user* u, int32_t d, object& o) +inline int template_callback_int32(unpack_user&, int32_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -inline int template_callback_int64(unpack_user* u, int64_t d, object& o) +inline int template_callback_int64(unpack_user&, int64_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } -inline int template_callback_float(unpack_user* u, float d, object& o) +inline int template_callback_float(unpack_user&, float d, object& o) { o.type = type::DOUBLE; o.via.dec = d; return 0; } -inline int template_callback_double(unpack_user* u, double d, object& o) +inline int template_callback_double(unpack_user&, double d, object& o) { o.type = type::DOUBLE; o.via.dec = d; return 0; } -inline int template_callback_nil(unpack_user* u, object& o) +inline int template_callback_nil(unpack_user&, object& o) { o.type = type::NIL; return 0; } -inline int template_callback_true(unpack_user* u, object& o) +inline int template_callback_true(unpack_user&, object& o) { o.type = type::BOOLEAN; o.via.boolean = true; return 0; } -inline int template_callback_false(unpack_user* u, object& o) +inline int template_callback_false(unpack_user&, object& o) { o.type = type::BOOLEAN; o.via.boolean = false; return 0; } -inline int template_callback_array(unpack_user* u, unsigned int n, object& o) +inline int template_callback_array(unpack_user&u, unsigned int n, object& o) { o.type = type::ARRAY; o.via.array.size = 0; - o.via.array.ptr = (object*)u->z().malloc(n*sizeof(object)); + o.via.array.ptr = (object*)u.z().malloc(n*sizeof(object)); if(o.via.array.ptr == NULL) { return -1; } return 0; } -inline int template_callback_array_item(unpack_user* u, object& c, object const& o) +inline int template_callback_array_item(unpack_user&, object& c, object const& o) { c.via.array.ptr[c.via.array.size++] = o; return 0; } -inline int template_callback_map(unpack_user* u, unsigned int n, object& o) +inline int template_callback_map(unpack_user& u, unsigned int n, object& o) { o.type = type::MAP; o.via.map.size = 0; - o.via.map.ptr = (object_kv*)u->z().malloc(n*sizeof(object_kv)); + o.via.map.ptr = (object_kv*)u.z().malloc(n*sizeof(object_kv)); if(o.via.map.ptr == NULL) { return -1; } return 0; } -inline int template_callback_map_item(unpack_user* u, object& c, object const& k, object const& v) +inline int template_callback_map_item(unpack_user&, object& c, object const& k, object const& v) { c.via.map.ptr[c.via.map.size].key = k; c.via.map.ptr[c.via.map.size].val = v; @@ -135,12 +135,12 @@ inline int template_callback_map_item(unpack_user* u, object& c, object const& k return 0; } -inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, object& o) +inline int template_callback_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) { o.type = type::RAW; o.via.raw.ptr = p; o.via.raw.size = l; - u->set_referenced(true); + u.set_referenced(true); return 0; } @@ -192,7 +192,7 @@ class template_context { public: template_context():cs_(CS_HEADER), trail_(0), top_(0) { - stack_[0].setObj(template_callback_root(&user_)); + stack_[0].setObj(template_callback_root(user_)); } void init() @@ -200,7 +200,7 @@ public: cs_ = CS_HEADER; trail_ = 0; top_ = 0; - stack_[0].setObj(template_callback_root(&user_)); + stack_[0].setObj(template_callback_root(user_)); } object const& data() const @@ -230,7 +230,6 @@ public: unsigned int cs = cs_; unsigned int top = top_; template_unpack_stack* stack = stack_; - unpack_user* user = &user_; object obj; template_unpack_stack* c = nullptr; @@ -244,23 +243,23 @@ public: case CS_HEADER: if (0) { } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum - if(template_callback_uint8(user, *(uint8_t*)p, obj) < 0) { goto _failed; } + if(template_callback_uint8(user_, *(uint8_t*)p, obj) < 0) { goto _failed; } goto _push; } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum - if(template_callback_int8(user, *(int8_t*)p, obj) < 0) { goto _failed; } + if(template_callback_int8(user_, *(int8_t*)p, obj) < 0) { goto _failed; } goto _push; } else if(0xc0 <= *p && *p <= 0xdf) { // Variable switch(*p) { case 0xc0: // nil - if(template_callback_nil(user, obj) < 0) { goto _failed; } + if(template_callback_nil(user_, obj) < 0) { goto _failed; } goto _push; //case 0xc1: // string // again_terminal_trail(next_cs(p), p+1); case 0xc2: // false - if(template_callback_false(user, obj) < 0) { goto _failed; } + if(template_callback_false(user_, obj) < 0) { goto _failed; } goto _push; case 0xc3: // true - if(template_callback_true(user, obj) < 0) { goto _failed; } + if(template_callback_true(user_, obj) < 0) { goto _failed; } goto _push; case 0xc4: // bin 8 case 0xc5: // bin 16 @@ -314,7 +313,7 @@ public: } else if(0x90 <= *p && *p <= 0x9f) { // FixArray if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } + if(template_callback_array(user_, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(((unsigned int)*p) & 0x0f); @@ -323,7 +322,7 @@ public: } else if(0x80 <= *p && *p <= 0x8f) { // FixMap if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } + if(template_callback_map(user_, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(((unsigned int)*p) & 0x0f); @@ -348,7 +347,7 @@ _fixed_trail_again: case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = _msgpack_load32(uint32_t,n); - if(template_callback_float(user, mem.f, obj) < 0) { goto _failed; } + if(template_callback_float(user_, mem.f, obj) < 0) { goto _failed; } goto _push; } case CS_DOUBLE: { union { uint64_t i; double f; } mem; @@ -357,32 +356,32 @@ _fixed_trail_again: // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - if(template_callback_double(user, mem.f, obj) < 0) { goto _failed; } + if(template_callback_double(user_, mem.f, obj) < 0) { goto _failed; } goto _push; } case CS_UINT_8: - if(template_callback_uint8(user, *(uint8_t*)n, obj) < 0) { goto _failed; } + if(template_callback_uint8(user_, *(uint8_t*)n, obj) < 0) { goto _failed; } goto _push; case CS_UINT_16: - if(template_callback_uint16(user, _msgpack_load16(uint16_t,n), obj) < 0) { goto _failed; } + if(template_callback_uint16(user_, _msgpack_load16(uint16_t,n), obj) < 0) { goto _failed; } goto _push; case CS_UINT_32: - if(template_callback_uint32(user, _msgpack_load32(uint32_t,n), obj) < 0) { goto _failed; } + if(template_callback_uint32(user_, _msgpack_load32(uint32_t,n), obj) < 0) { goto _failed; } goto _push; case CS_UINT_64: - if(template_callback_uint64(user, _msgpack_load64(uint64_t,n), obj) < 0) { goto _failed; } + if(template_callback_uint64(user_, _msgpack_load64(uint64_t,n), obj) < 0) { goto _failed; } goto _push; case CS_INT_8: - if(template_callback_int8(user, *(int8_t*)n, obj) < 0) { goto _failed; } + if(template_callback_int8(user_, *(int8_t*)n, obj) < 0) { goto _failed; } goto _push; case CS_INT_16: - if(template_callback_int16(user, _msgpack_load16(int16_t,n), obj) < 0) { goto _failed; } + if(template_callback_int16(user_, _msgpack_load16(int16_t,n), obj) < 0) { goto _failed; } goto _push; case CS_INT_32: - if(template_callback_int32(user, _msgpack_load32(int32_t,n), obj) < 0) { goto _failed; } + if(template_callback_int32(user_, _msgpack_load32(int32_t,n), obj) < 0) { goto _failed; } goto _push; case CS_INT_64: - if(template_callback_int64(user, _msgpack_load64(int64_t,n), obj) < 0) { goto _failed; } + if(template_callback_int64(user_, _msgpack_load64(int64_t,n), obj) < 0) { goto _failed; } goto _push; case CS_BIN_8: @@ -405,11 +404,11 @@ _fixed_trail_again: goto _fixed_trail_again; case ACS_RAW_VALUE: _raw_zero: - if(template_callback_raw(user, (const char*)data, (const char*)n, trail, obj) < 0) { goto _failed; } + if(template_callback_raw(user_, (const char*)data, (const char*)n, trail, obj) < 0) { goto _failed; } goto _push; case CS_ARRAY_16: if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } + if(template_callback_array(user_, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(_msgpack_load16(uint16_t, n)); @@ -418,7 +417,7 @@ _raw_zero: case CS_ARRAY_32: /* FIXME security guard */ if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } + if(template_callback_array(user_, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(_msgpack_load32(uint32_t, n)); @@ -427,7 +426,7 @@ _raw_zero: case CS_MAP_16: if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } + if(template_callback_map(user_, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(_msgpack_load16(uint16_t, n)); @@ -436,7 +435,7 @@ _raw_zero: case CS_MAP_32: /* FIXME security guard */ if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } + if(template_callback_map(user_, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(_msgpack_load32(uint32_t, n)); @@ -453,7 +452,7 @@ _push: c = &stack[top-1]; switch(c->ct()) { case CT_ARRAY_ITEM: - if(template_callback_array_item(user, c->obj(), obj) < 0) { goto _failed; } + if(template_callback_array_item(user_, c->obj(), obj) < 0) { goto _failed; } if(c->decl_count() == 0) { obj = c->obj(); --top; @@ -466,7 +465,7 @@ _push: c->set_ct(CT_MAP_VALUE); goto _header_again; case CT_MAP_VALUE: - if(template_callback_map_item(user, c->obj(), c->map_key(), obj) < 0) { goto _failed; } + if(template_callback_map_item(user_, c->obj(), c->map_key(), obj) < 0) { goto _failed; } if(c->decl_count() == 0) { obj = c->obj(); --top; From 27629a8dd688a30d9eeae27d7a0ff5c38bd060c4 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 16:53:47 +0900 Subject: [PATCH 020/153] Modified 'unpacked' interface using references instead of pointers. Added speed test for 'unpacked' based unpack() function. --- example/speed_test.cc | 10 ++++++++++ src/msgpack/unpack.hpp | 20 ++++++++++---------- test/fixint.cc | 2 +- test/pack_unpack.cc | 6 +++--- 4 files changed, 24 insertions(+), 14 deletions(-) diff --git a/example/speed_test.cc b/example/speed_test.cc index 267c042b..589fbe40 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -36,6 +36,16 @@ void test_map_pack_unpack() { std::cout << result << std::endl; } std::cout << "Unpack finished..." << std::endl; + + msgpack::unpacked unpacked; + std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(unpacked, str.data(), str.size()); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; } diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 6b538760..694b75c4 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -542,8 +542,8 @@ public: unpacked(object const& obj, msgpack::unique_ptr z) : m_obj(obj), m_zone(msgpack::move(z)) { } - object& get() - { return m_obj; } + void set(object const& obj) + { m_obj = obj; } const object& get() const { return m_obj; } @@ -670,7 +670,7 @@ private: }; -static void unpack(unpacked* result, +static void unpack(unpacked& result, const char* data, size_t len, size_t* offset = NULL); @@ -824,12 +824,12 @@ inline bool unpacker::next(unpacked* result) if(ret == 0) { result->zone().reset(); - result->get() = object(); + result->set(object()); return false; } else { result->zone().reset( release_zone() ); - result->get() = data(); + result->set(data()); reset(); return true; } @@ -981,7 +981,7 @@ unpack_imp(const char* data, size_t len, size_t* off, } // detail -inline void unpack(unpacked* result, +inline void unpack(unpacked& result, const char* data, size_t len, size_t* offset) { object obj; @@ -993,13 +993,13 @@ inline void unpack(unpacked* result, switch(ret) { case UNPACK_SUCCESS: - result->get() = obj; - result->zone() = msgpack::move(z); + result.set(obj); + result.zone() = msgpack::move(z); return; case UNPACK_EXTRA_BYTES: - result->get() = obj; - result->zone() = msgpack::move(z); + result.set(obj); + result.zone() = msgpack::move(z); return; case UNPACK_CONTINUE: diff --git a/test/fixint.cc b/test/fixint.cc index 63288a1b..a45edb90 100644 --- a/test/fixint.cc +++ b/test/fixint.cc @@ -30,7 +30,7 @@ void check_convert() { msgpack::pack(sbuf, v1); msgpack::unpacked msg; - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + msgpack::unpack(msg, sbuf.data(), sbuf.size()); T v2; msg.get().convert(&v2); diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index 6718a01b..fd42bc4d 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -81,13 +81,13 @@ TEST(unpack, sequence) msgpack::unpacked msg; - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); EXPECT_EQ(1, msg.get().as()); - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); EXPECT_EQ(2, msg.get().as()); - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); EXPECT_EQ(3, msg.get().as()); } From 7ce8abe5d6c3d3a1458e4f153f1359452ed8d4ea Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 17:59:16 +0900 Subject: [PATCH 021/153] Tabified. Indent adjusted. --- src/msgpack/pack.hpp | 619 +++++++++++++++++++++---------------------- 1 file changed, 301 insertions(+), 318 deletions(-) diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index 3f9e21a1..c4c13477 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -112,7 +112,7 @@ private: template inline void pack(Stream* s, const T& v) { - packer(s).pack(v); + packer(*s).pack(v); } template @@ -121,23 +121,6 @@ inline void pack(Stream& s, const T& v) packer(s).pack(v); } - -#define msgpack_pack_inline_func(name) \ - template \ - inline void packer::_pack ## name - -#define msgpack_pack_inline_func_cint(name) \ - template \ - inline void packer::_pack ## name - -#define msgpack_pack_inline_func_fixint(name) \ - template \ - inline void packer::_pack_fix ## name - -#define msgpack_pack_user Stream& - -#define msgpack_pack_append_buffer append_buffer - #if defined(__LITTLE_ENDIAN__) #define TAKE8_8(d) ((uint8_t*)&d)[0] #define TAKE8_16(d) ((uint8_t*)&d)[0] @@ -197,70 +180,70 @@ template inline packer& packer::pack_fix_uint8(uint8_t d) { unsigned char buf[2] = {0xcc, TAKE8_8(d)}; - append_buffer(buf, 2); - return *this; + append_buffer(buf, 2); + return *this; } template inline packer& packer::pack_fix_uint16(uint16_t d) -{ +{ unsigned char buf[3]; buf[0] = 0xcd; _msgpack_store16(&buf[1], d); - append_buffer(buf, 3); - return *this; + append_buffer(buf, 3); + return *this; } template inline packer& packer::pack_fix_uint32(uint32_t d) -{ +{ unsigned char buf[5]; buf[0] = 0xce; _msgpack_store32(&buf[1], d); - append_buffer(buf, 5); - return *this; + append_buffer(buf, 5); + return *this; } template inline packer& packer::pack_fix_uint64(uint64_t d) -{ +{ unsigned char buf[9]; buf[0] = 0xcf; _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - return *this; + append_buffer(buf, 9); + return *this; } template inline packer& packer::pack_fix_int8(int8_t d) -{ +{ unsigned char buf[2] = {0xd0, TAKE8_8(d)}; - append_buffer(buf, 2); - return *this; + append_buffer(buf, 2); + return *this; } template inline packer& packer::pack_fix_int16(int16_t d) -{ +{ unsigned char buf[3]; buf[0] = 0xd1; _msgpack_store16(&buf[1], d); - append_buffer(buf, 3); - return *this; + append_buffer(buf, 3); + return *this; } template inline packer& packer::pack_fix_int32(int32_t d) -{ +{ unsigned char buf[5]; buf[0] = 0xd2; _msgpack_store32(&buf[1], d); - append_buffer(buf, 5); - return *this; + append_buffer(buf, 5); + return *this; } template inline packer& packer::pack_fix_int64(int64_t d) -{ +{ unsigned char buf[9]; buf[0] = 0xd3; _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - return *this; + append_buffer(buf, 9); + return *this; } @@ -294,13 +277,13 @@ inline packer& packer::pack_short(short d) #endif #else -if(sizeof(short) == 2) { - pack_real_int16(d); -} else if(sizeof(short) == 4) { - pack_real_int32(d); -} else { - pack_real_int64(d); -} + if(sizeof(short) == 2) { + pack_real_int16(d); + } else if(sizeof(short) == 4) { + pack_real_int32(d); + } else { + pack_real_int64(d); + } #endif return *this; } @@ -327,13 +310,13 @@ inline packer& packer::pack_int(int d) #endif #else -if(sizeof(int) == 2) { - pack_real_int16(d); -} else if(sizeof(int) == 4) { - pack_real_int32(d); -} else { - pack_real_int64(d); -} + if(sizeof(int) == 2) { + pack_real_int16(d); + } else if(sizeof(int) == 4) { + pack_real_int32(d); + } else { + pack_real_int64(d); + } #endif return *this; } @@ -360,13 +343,13 @@ inline packer& packer::pack_long(long d) #endif #else -if(sizeof(long) == 2) { - pack_real_int16(d); -} else if(sizeof(long) == 4) { - pack_real_int32(d); -} else { - pack_real_int64(d); -} + if(sizeof(long) == 2) { + pack_real_int16(d); + } else if(sizeof(long) == 4) { + pack_real_int32(d); + } else { + pack_real_int64(d); + } #endif return *this; } @@ -393,13 +376,13 @@ inline packer& packer::pack_long_long(long long d) #endif #else -if(sizeof(long long) == 2) { - pack_real_int16(d); -} else if(sizeof(long long) == 4) { - pack_real_int32(d); -} else { - pack_real_int64(d); -} + if(sizeof(long long) == 2) { + pack_real_int16(d); + } else if(sizeof(long long) == 4) { + pack_real_int32(d); + } else { + pack_real_int64(d); + } #endif return *this; } @@ -431,13 +414,13 @@ inline packer& packer::pack_unsigned_short(unsigned short d) #endif #else -if(sizeof(unsigned short) == 2) { - pack_real_uint16(d); -} else if(sizeof(unsigned short) == 4) { - pack_real_uint32(d); -} else { - pack_real_uint64(d); -} + if(sizeof(unsigned short) == 2) { + pack_real_uint16(d); + } else if(sizeof(unsigned short) == 4) { + pack_real_uint32(d); + } else { + pack_real_uint64(d); + } #endif return *this; } @@ -464,13 +447,13 @@ inline packer& packer::pack_unsigned_int(unsigned int d) #endif #else -if(sizeof(unsigned int) == 2) { - pack_real_uint16(d); -} else if(sizeof(unsigned int) == 4) { - pack_real_uint32(d); -} else { - pack_real_uint64(d); -} + if(sizeof(unsigned int) == 2) { + pack_real_uint16(d); + } else if(sizeof(unsigned int) == 4) { + pack_real_uint32(d); + } else { + pack_real_uint64(d); + } #endif return *this; } @@ -497,13 +480,13 @@ inline packer& packer::pack_unsigned_long(unsigned long d) #endif #else -if(sizeof(unsigned long) == 2) { - pack_real_uint16(d); -} else if(sizeof(unsigned long) == 4) { - pack_real_uint32(d); -} else { - pack_real_uint64(d); -} + if(sizeof(unsigned long) == 2) { + pack_real_uint16(d); + } else if(sizeof(unsigned long) == 4) { + pack_real_uint32(d); + } else { + pack_real_uint64(d); + } #endif return *this; } @@ -530,13 +513,13 @@ inline packer& packer::pack_unsigned_long_long(unsigned long lon #endif #else -if(sizeof(unsigned long long) == 2) { - pack_real_uint16(d); -} else if(sizeof(unsigned long long) == 4) { - pack_real_uint32(d); -} else { - pack_real_uint64(d); -} + if(sizeof(unsigned long long) == 2) { + pack_real_uint16(d); + } else if(sizeof(unsigned long long) == 4) { + pack_real_uint32(d); + } else { + pack_real_uint64(d); + } #endif return *this; } @@ -561,10 +544,10 @@ inline packer& packer::pack_double(double d) unsigned char buf[9]; buf[0] = 0xcb; #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - _msgpack_store64(&buf[1], mem.i); + _msgpack_store64(&buf[1], mem.i); append_buffer(buf, 9); return *this; } @@ -658,245 +641,245 @@ inline packer& packer::pack_raw_body(const char* b, size_t l) template template -inline void packer::pack_real_uint8(T d) -{ - if(d < (1<<7)) { - /* fixnum */ - append_buffer(&TAKE8_8(d), 1); - } else { - /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; - append_buffer(buf, 2); - } -} +inline void packer::pack_real_uint8(T d) +{ + if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_8(d), 1); + } else { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_8(d)}; + append_buffer(buf, 2); + } +} template template -inline void packer::pack_real_uint16(T d) -{ - if(d < (1<<7)) { - /* fixnum */ - append_buffer(&TAKE8_16(d), 1); - } else if(d < (1<<8)) { - /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); - append_buffer(buf, 3); - } -} +inline void packer::pack_real_uint16(T d) +{ + if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_16(d), 1); + } else if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } +} template template -inline void packer::pack_real_uint32(T d) -{ - if(d < (1<<8)) { - if(d < (1<<7)) { - /* fixnum */ - append_buffer(&TAKE8_32(d), 1); - } else { - /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; - append_buffer(buf, 2); - } - } else { - if(d < (1<<16)) { - /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); - append_buffer(buf, 3); - } else { - /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); - append_buffer(buf, 5); - } - } -} +inline void packer::pack_real_uint32(T d) +{ + if(d < (1<<8)) { + if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_32(d), 1); + } else { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1<<16)) { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } + } +} template template -inline void packer::pack_real_uint64(T d) -{ - if(d < (1ULL<<8)) { - if(d < (1ULL<<7)) { - /* fixnum */ - append_buffer(&TAKE8_64(d), 1); - } else { - /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; - append_buffer(buf, 2); - } - } else { - if(d < (1ULL<<16)) { - /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); - append_buffer(buf, 3); - } else if(d < (1ULL<<32)) { - /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); - append_buffer(buf, 5); - } else { - /* unsigned 64 */ - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } - } -} +inline void packer::pack_real_uint64(T d) +{ + if(d < (1ULL<<8)) { + if(d < (1ULL<<7)) { + /* fixnum */ + append_buffer(&TAKE8_64(d), 1); + } else { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1ULL<<16)) { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } else if(d < (1ULL<<32)) { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + unsigned char buf[9]; + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } +} template template -inline void packer::pack_real_int8(T d) -{ - if(d < -(1<<5)) { - /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; - append_buffer(buf, 2); - } else { - /* fixnum */ - append_buffer(&TAKE8_8(d), 1); - } -} +inline void packer::pack_real_int8(T d) +{ + if(d < -(1<<5)) { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_8(d)}; + append_buffer(buf, 2); + } else { + /* fixnum */ + append_buffer(&TAKE8_8(d), 1); + } +} template template -inline void packer::pack_real_int16(T d) -{ - if(d < -(1<<5)) { - if(d < -(1<<7)) { - /* signed 16 */ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); - append_buffer(buf, 3); - } else { - /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_16(d)}; - append_buffer(buf, 2); - } - } else if(d < (1<<7)) { - /* fixnum */ - append_buffer(&TAKE8_16(d), 1); - } else { - if(d < (1<<8)) { - /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); - append_buffer(buf, 3); - } - } -} +inline void packer::pack_real_int16(T d) +{ + if(d < -(1<<5)) { + if(d < -(1<<7)) { + /* signed 16 */ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + append_buffer(buf, 3); + } else { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_16(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_16(d), 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } + } +} template template -inline void packer::pack_real_int32(T d) -{ - if(d < -(1<<5)) { - if(d < -(1<<15)) { - /* signed 32 */ - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); - append_buffer(buf, 5); - } else if(d < -(1<<7)) { - /* signed 16 */ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); - append_buffer(buf, 3); - } else { - /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_32(d)}; - append_buffer(buf, 2); - } - } else if(d < (1<<7)) { - /* fixnum */ - append_buffer(&TAKE8_32(d), 1); - } else { - if(d < (1<<8)) { - /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; - append_buffer(buf, 2); - } else if(d < (1<<16)) { - /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); - append_buffer(buf, 3); - } else { - /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); - append_buffer(buf, 5); - } - } -} +inline void packer::pack_real_int32(T d) +{ + if(d < -(1<<5)) { + if(d < -(1<<15)) { + /* signed 32 */ + unsigned char buf[5]; + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); + append_buffer(buf, 5); + } else if(d < -(1<<7)) { + /* signed 16 */ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + append_buffer(buf, 3); + } else { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_32(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_32(d), 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; + append_buffer(buf, 2); + } else if(d < (1<<16)) { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } + } +} template template -inline void packer::pack_real_int64(T d) -{ - if(d < -(1LL<<5)) { - if(d < -(1LL<<15)) { - if(d < -(1LL<<31)) { - /* signed 64 */ - unsigned char buf[9]; - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } else { - /* signed 32 */ - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); - append_buffer(buf, 5); - } - } else { - if(d < -(1<<7)) { - /* signed 16 */ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); - append_buffer(buf, 3); - } else { - /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_64(d)}; - append_buffer(buf, 2); - } - } - } else if(d < (1<<7)) { - /* fixnum */ - append_buffer(&TAKE8_64(d), 1); - } else { - if(d < (1LL<<16)) { - if(d < (1<<8)) { - /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); - append_buffer(buf, 3); - } - } else { - if(d < (1LL<<32)) { - /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); - append_buffer(buf, 5); - } else { - /* unsigned 64 */ - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } - } - } -} +inline void packer::pack_real_int64(T d) +{ + if(d < -(1LL<<5)) { + if(d < -(1LL<<15)) { + if(d < -(1LL<<31)) { + /* signed 64 */ + unsigned char buf[9]; + buf[0] = 0xd3; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } else { + /* signed 32 */ + unsigned char buf[5]; + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); + append_buffer(buf, 5); + } + } else { + if(d < -(1<<7)) { + /* signed 16 */ + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + append_buffer(buf, 3); + } else { + /* signed 8 */ + unsigned char buf[2] = {0xd0, TAKE8_64(d)}; + append_buffer(buf, 2); + } + } + } else if(d < (1<<7)) { + /* fixnum */ + append_buffer(&TAKE8_64(d), 1); + } else { + if(d < (1LL<<16)) { + if(d < (1<<8)) { + /* unsigned 8 */ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + append_buffer(buf, 3); + } + } else { + if(d < (1LL<<32)) { + /* unsigned 32 */ + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + unsigned char buf[9]; + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } + } +} } // namespace msgpack From aa4ed82b66b74a80e07382bd0a26349f5d70b412 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Sep 2013 19:20:46 +0900 Subject: [PATCH 022/153] Replaced TAKE8_* macros with inline function named take8_*. Modified byte stream using char instead of unsigned char. --- src/msgpack/pack.hpp | 233 +++++++++++++++++++++++++------------------ 1 file changed, 135 insertions(+), 98 deletions(-) diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index c4c13477..3c90eee5 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -98,8 +98,8 @@ private: template void pack_real_int64(T d); - void append_buffer(const unsigned char* buf, unsigned int len) - { m_stream.write((const char*)buf, len); } + void append_buffer(const char* buf, unsigned int len) + { m_stream.write(buf, len); } private: Stream& m_stream; @@ -122,15 +122,42 @@ inline void pack(Stream& s, const T& v) } #if defined(__LITTLE_ENDIAN__) -#define TAKE8_8(d) ((uint8_t*)&d)[0] -#define TAKE8_16(d) ((uint8_t*)&d)[0] -#define TAKE8_32(d) ((uint8_t*)&d)[0] -#define TAKE8_64(d) ((uint8_t*)&d)[0] +template +inline char take8_8(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_16(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_32(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_64(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} + #elif defined(__BIG_ENDIAN__) -#define TAKE8_8(d) ((uint8_t*)&d)[0] -#define TAKE8_16(d) ((uint8_t*)&d)[1] -#define TAKE8_32(d) ((uint8_t*)&d)[3] -#define TAKE8_64(d) ((uint8_t*)&d)[7] + +template +inline char take8_8(T d) { + return static_cast(reinterpret_cast(&d)[0]); +} +template +inline char take8_16(T d) { + return static_cast(reinterpret_cast(&d)[1]); +} +template +inline char take8_32(T d) { + return static_cast(reinterpret_cast(&d)[3]); +} +template +inline char take8_64(T d) { + return static_cast(reinterpret_cast(&d)[7]); +} + #endif template @@ -179,7 +206,7 @@ inline packer& packer::pack_int64(int64_t d) template inline packer& packer::pack_fix_uint8(uint8_t d) { - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; + char buf[2] = {static_cast(0xcc), take8_8(d)}; append_buffer(buf, 2); return *this; } @@ -187,8 +214,8 @@ inline packer& packer::pack_fix_uint8(uint8_t d) template inline packer& packer::pack_fix_uint16(uint16_t d) { - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], d); + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], d); append_buffer(buf, 3); return *this; } @@ -196,8 +223,8 @@ inline packer& packer::pack_fix_uint16(uint16_t d) template inline packer& packer::pack_fix_uint32(uint32_t d) { - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], d); + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], d); append_buffer(buf, 5); return *this; } @@ -205,8 +232,8 @@ inline packer& packer::pack_fix_uint32(uint32_t d) template inline packer& packer::pack_fix_uint64(uint64_t d) { - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); append_buffer(buf, 9); return *this; } @@ -214,7 +241,7 @@ inline packer& packer::pack_fix_uint64(uint64_t d) template inline packer& packer::pack_fix_int8(int8_t d) { - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; + char buf[2] = {static_cast(0xd0), take8_8(d)}; append_buffer(buf, 2); return *this; } @@ -222,8 +249,8 @@ inline packer& packer::pack_fix_int8(int8_t d) template inline packer& packer::pack_fix_int16(int16_t d) { - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], d); + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], d); append_buffer(buf, 3); return *this; } @@ -231,8 +258,8 @@ inline packer& packer::pack_fix_int16(int16_t d) template inline packer& packer::pack_fix_int32(int32_t d) { - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], d); + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], d); append_buffer(buf, 5); return *this; } @@ -240,8 +267,8 @@ inline packer& packer::pack_fix_int32(int32_t d) template inline packer& packer::pack_fix_int64(int64_t d) { - unsigned char buf[9]; - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); + char buf[9]; + buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); append_buffer(buf, 9); return *this; } @@ -530,7 +557,7 @@ inline packer& packer::pack_float(float d) { union { float f; uint32_t i; } mem; mem.f = d; - unsigned char buf[5]; + char buf[5]; buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); append_buffer(buf, 5); return *this; @@ -541,7 +568,7 @@ inline packer& packer::pack_double(double d) { union { double f; uint64_t i; } mem; mem.f = d; - unsigned char buf[9]; + char buf[9]; buf[0] = 0xcb; #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 @@ -556,7 +583,7 @@ inline packer& packer::pack_double(double d) template inline packer& packer::pack_nil() { - static const unsigned char d = 0xc0; + const char d = static_cast(0xc0); append_buffer(&d, 1); return *this; } @@ -564,7 +591,7 @@ inline packer& packer::pack_nil() template inline packer& packer::pack_true() { - static const unsigned char d = 0xc3; + const char d = static_cast(0xc3); append_buffer(&d, 1); return *this; } @@ -572,7 +599,7 @@ inline packer& packer::pack_true() template inline packer& packer::pack_false() { - static const unsigned char d = 0xc2; + const char d = static_cast(0xc2); append_buffer(&d, 1); return *this; } @@ -582,15 +609,15 @@ template inline packer& packer::pack_array(size_t n) { if(n < 16) { - unsigned char d = 0x90 | n; + char d = static_cast(0x90 | n); append_buffer(&d, 1); } else if(n < 65536) { - unsigned char buf[3]; - buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); + char buf[3]; + buf[0] = static_cast(0xdc); _msgpack_store16(&buf[1], (uint16_t)n); append_buffer(buf, 3); } else { - unsigned char buf[5]; - buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); + char buf[5]; + buf[0] = static_cast(0xdd); _msgpack_store32(&buf[1], (uint32_t)n); append_buffer(buf, 5); } return *this; @@ -601,13 +628,14 @@ inline packer& packer::pack_map(size_t n) { if(n < 16) { unsigned char d = 0x80 | n; - append_buffer(&TAKE8_8(d), 1); + char buf = take8_8(d); + append_buffer(&buf, 1); } else if(n < 65536) { - unsigned char buf[3]; + char buf[3]; buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); append_buffer(buf, 3); } else { - unsigned char buf[5]; + char buf[5]; buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); append_buffer(buf, 5); } @@ -619,14 +647,15 @@ inline packer& packer::pack_raw(size_t l) { if(l < 32) { unsigned char d = 0xa0 | (uint8_t)l; - append_buffer(&TAKE8_8(d), 1); + char buf = take8_8(d); + append_buffer(&buf, 1); } else if(l < 65536) { - unsigned char buf[3]; - buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); + char buf[3]; + buf[0] = static_cast(0xda); _msgpack_store16(&buf[1], (uint16_t)l); append_buffer(buf, 3); } else { - unsigned char buf[5]; - buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); + char buf[5]; + buf[0] = static_cast(0xdb); _msgpack_store32(&buf[1], (uint32_t)l); append_buffer(buf, 5); } return *this; @@ -635,7 +664,7 @@ inline packer& packer::pack_raw(size_t l) template inline packer& packer::pack_raw_body(const char* b, size_t l) { - append_buffer((const unsigned char*)b, l); + append_buffer(b, l); return *this; } @@ -645,10 +674,11 @@ inline void packer::pack_real_uint8(T d) { if(d < (1<<7)) { /* fixnum */ - append_buffer(&TAKE8_8(d), 1); + char buf = take8_8(d); + append_buffer(&buf, 1); } else { /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; + char buf[2] = {static_cast(0xcc), take8_8(d)}; append_buffer(buf, 2); } } @@ -659,15 +689,16 @@ inline void packer::pack_real_uint16(T d) { if(d < (1<<7)) { /* fixnum */ - append_buffer(&TAKE8_16(d), 1); + char buf = take8_16(d); + append_buffer(&buf, 1); } else if(d < (1<<8)) { /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; + char buf[2] = {static_cast(0xcc), take8_16(d)}; append_buffer(buf, 2); } else { /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); append_buffer(buf, 3); } } @@ -679,22 +710,23 @@ inline void packer::pack_real_uint32(T d) if(d < (1<<8)) { if(d < (1<<7)) { /* fixnum */ - append_buffer(&TAKE8_32(d), 1); + char buf = take8_32(d); + append_buffer(&buf, 1); } else { /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; + char buf[2] = {static_cast(0xcc), take8_32(d)}; append_buffer(buf, 2); } } else { if(d < (1<<16)) { /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); append_buffer(buf, 3); } else { /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); append_buffer(buf, 5); } } @@ -707,27 +739,28 @@ inline void packer::pack_real_uint64(T d) if(d < (1ULL<<8)) { if(d < (1ULL<<7)) { /* fixnum */ - append_buffer(&TAKE8_64(d), 1); + char buf = take8_64(d); + append_buffer(&buf, 1); } else { /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; + char buf[2] = {static_cast(0xcc), take8_64(d)}; append_buffer(buf, 2); } } else { if(d < (1ULL<<16)) { /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); append_buffer(buf, 3); } else if(d < (1ULL<<32)) { /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); append_buffer(buf, 5); } else { /* unsigned 64 */ - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); append_buffer(buf, 9); } } @@ -739,11 +772,12 @@ inline void packer::pack_real_int8(T d) { if(d < -(1<<5)) { /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; + char buf[2] = {static_cast(0xd0), take8_8(d)}; append_buffer(buf, 2); } else { /* fixnum */ - append_buffer(&TAKE8_8(d), 1); + char buf = take8_8(d); + append_buffer(&buf, 1); } } @@ -754,26 +788,27 @@ inline void packer::pack_real_int16(T d) if(d < -(1<<5)) { if(d < -(1<<7)) { /* signed 16 */ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], (int16_t)d); append_buffer(buf, 3); } else { /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_16(d)}; + char buf[2] = {static_cast(0xd0), take8_16(d)}; append_buffer(buf, 2); } } else if(d < (1<<7)) { /* fixnum */ - append_buffer(&TAKE8_16(d), 1); + char buf = take8_16(d); + append_buffer(&buf, 1); } else { if(d < (1<<8)) { /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; + char buf[2] = {static_cast(0xcc), take8_16(d)}; append_buffer(buf, 2); } else { /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); append_buffer(buf, 3); } } @@ -786,36 +821,37 @@ inline void packer::pack_real_int32(T d) if(d < -(1<<5)) { if(d < -(1<<15)) { /* signed 32 */ - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], (int32_t)d); append_buffer(buf, 5); } else if(d < -(1<<7)) { /* signed 16 */ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], (int16_t)d); append_buffer(buf, 3); } else { /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_32(d)}; + char buf[2] = { static_cast(0xd0), take8_32(d)}; append_buffer(buf, 2); } } else if(d < (1<<7)) { /* fixnum */ - append_buffer(&TAKE8_32(d), 1); + char buf = take8_32(d); + append_buffer(&buf, 1); } else { if(d < (1<<8)) { /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; + char buf[2] = { static_cast(0xcc), take8_32(d)}; append_buffer(buf, 2); } else if(d < (1<<16)) { /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); append_buffer(buf, 3); } else { /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); append_buffer(buf, 5); } } @@ -829,52 +865,53 @@ inline void packer::pack_real_int64(T d) if(d < -(1LL<<15)) { if(d < -(1LL<<31)) { /* signed 64 */ - unsigned char buf[9]; - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); + char buf[9]; + buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); append_buffer(buf, 9); } else { /* signed 32 */ - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], (int32_t)d); append_buffer(buf, 5); } } else { if(d < -(1<<7)) { /* signed 16 */ - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], (int16_t)d); append_buffer(buf, 3); } else { /* signed 8 */ - unsigned char buf[2] = {0xd0, TAKE8_64(d)}; + char buf[2] = {static_cast(0xd0), take8_64(d)}; append_buffer(buf, 2); } } } else if(d < (1<<7)) { /* fixnum */ - append_buffer(&TAKE8_64(d), 1); + char buf = take8_64(d); + append_buffer(&buf, 1); } else { if(d < (1LL<<16)) { if(d < (1<<8)) { /* unsigned 8 */ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; + char buf[2] = {static_cast(0xcc), take8_64(d)}; append_buffer(buf, 2); } else { /* unsigned 16 */ - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); append_buffer(buf, 3); } } else { if(d < (1LL<<32)) { /* unsigned 32 */ - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); append_buffer(buf, 5); } else { /* unsigned 64 */ - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); append_buffer(buf, 9); } } From 1fb707f93f173edf0b302bdbb3bf06760172f190 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 09:47:55 +0900 Subject: [PATCH 023/153] Renamed functions from pack_real_* to pack_imp_*. --- src/msgpack/pack.hpp | 192 +++++++++++++++++++++---------------------- 1 file changed, 96 insertions(+), 96 deletions(-) diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index 3c90eee5..c18385fb 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -82,21 +82,21 @@ public: private: template - void pack_real_uint8(T d); + void pack_imp_uint8(T d); template - void pack_real_uint16(T d); + void pack_imp_uint16(T d); template - void pack_real_uint32(T d); + void pack_imp_uint32(T d); template - void pack_real_uint64(T d); + void pack_imp_uint64(T d); template - void pack_real_int8(T d); + void pack_imp_int8(T d); template - void pack_real_int16(T d); + void pack_imp_int16(T d); template - void pack_real_int32(T d); + void pack_imp_int32(T d); template - void pack_real_int64(T d); + void pack_imp_int64(T d); void append_buffer(const char* buf, unsigned int len) { m_stream.write(buf, len); } @@ -172,35 +172,35 @@ packer::~packer() { } template inline packer& packer::pack_uint8(uint8_t d) -{ pack_real_uint8(d); return *this; } +{ pack_imp_uint8(d); return *this; } template inline packer& packer::pack_uint16(uint16_t d) -{ pack_real_uint16(d); return *this; } +{ pack_imp_uint16(d); return *this; } template inline packer& packer::pack_uint32(uint32_t d) -{ pack_real_uint32(d); return *this; } +{ pack_imp_uint32(d); return *this; } template inline packer& packer::pack_uint64(uint64_t d) -{ pack_real_uint64(d); return *this; } +{ pack_imp_uint64(d); return *this; } template inline packer& packer::pack_int8(int8_t d) -{ pack_real_int8(d); return *this; } +{ pack_imp_int8(d); return *this; } template inline packer& packer::pack_int16(int16_t d) -{ pack_real_int16(d); return *this; } +{ pack_imp_int16(d); return *this; } template inline packer& packer::pack_int32(int32_t d) -{ pack_real_int32(d); return *this; } +{ pack_imp_int32(d); return *this; } template inline packer& packer::pack_int64(int64_t d) -{ pack_real_int64(d); return *this;} +{ pack_imp_int64(d); return *this;} template @@ -287,29 +287,29 @@ inline packer& packer::pack_short(short d) { #if defined(SIZEOF_SHORT) #if SIZEOF_SHORT == 2 - pack_real_int16(d); + pack_imp_int16(d); #elif SIZEOF_SHORT == 4 - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #elif defined(SHRT_MAX) #if SHRT_MAX == 0x7fff - pack_real_int16(d); + pack_imp_int16(d); #elif SHRT_MAX == 0x7fffffff - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #else if(sizeof(short) == 2) { - pack_real_int16(d); + pack_imp_int16(d); } else if(sizeof(short) == 4) { - pack_real_int32(d); + pack_imp_int32(d); } else { - pack_real_int64(d); + pack_imp_int64(d); } #endif return *this; @@ -320,29 +320,29 @@ inline packer& packer::pack_int(int d) { #if defined(SIZEOF_INT) #if SIZEOF_INT == 2 - pack_real_int16(d); + pack_imp_int16(d); #elif SIZEOF_INT == 4 - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #elif defined(INT_MAX) #if INT_MAX == 0x7fff - pack_real_int16(d); + pack_imp_int16(d); #elif INT_MAX == 0x7fffffff - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #else if(sizeof(int) == 2) { - pack_real_int16(d); + pack_imp_int16(d); } else if(sizeof(int) == 4) { - pack_real_int32(d); + pack_imp_int32(d); } else { - pack_real_int64(d); + pack_imp_int64(d); } #endif return *this; @@ -353,29 +353,29 @@ inline packer& packer::pack_long(long d) { #if defined(SIZEOF_LONG) #if SIZEOF_LONG == 2 - pack_real_int16(d); + pack_imp_int16(d); #elif SIZEOF_LONG == 4 - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #elif defined(LONG_MAX) #if LONG_MAX == 0x7fffL - pack_real_int16(d); + pack_imp_int16(d); #elif LONG_MAX == 0x7fffffffL - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #else if(sizeof(long) == 2) { - pack_real_int16(d); + pack_imp_int16(d); } else if(sizeof(long) == 4) { - pack_real_int32(d); + pack_imp_int32(d); } else { - pack_real_int64(d); + pack_imp_int64(d); } #endif return *this; @@ -386,29 +386,29 @@ inline packer& packer::pack_long_long(long long d) { #if defined(SIZEOF_LONG_LONG) #if SIZEOF_LONG_LONG == 2 - pack_real_int16(d); + pack_imp_int16(d); #elif SIZEOF_LONG_LONG == 4 - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #elif defined(LLONG_MAX) #if LLONG_MAX == 0x7fffL - pack_real_int16(d); + pack_imp_int16(d); #elif LLONG_MAX == 0x7fffffffL - pack_real_int32(d); + pack_imp_int32(d); #else - pack_real_int64(d); + pack_imp_int64(d); #endif #else if(sizeof(long long) == 2) { - pack_real_int16(d); + pack_imp_int16(d); } else if(sizeof(long long) == 4) { - pack_real_int32(d); + pack_imp_int32(d); } else { - pack_real_int64(d); + pack_imp_int64(d); } #endif return *this; @@ -424,29 +424,29 @@ inline packer& packer::pack_unsigned_short(unsigned short d) { #if defined(SIZEOF_SHORT) #if SIZEOF_SHORT == 2 - pack_real_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_SHORT == 4 - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #elif defined(USHRT_MAX) #if USHRT_MAX == 0xffffU - pack_real_uint16(d); + pack_imp_uint16(d); #elif USHRT_MAX == 0xffffffffU - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #else if(sizeof(unsigned short) == 2) { - pack_real_uint16(d); + pack_imp_uint16(d); } else if(sizeof(unsigned short) == 4) { - pack_real_uint32(d); + pack_imp_uint32(d); } else { - pack_real_uint64(d); + pack_imp_uint64(d); } #endif return *this; @@ -457,29 +457,29 @@ inline packer& packer::pack_unsigned_int(unsigned int d) { #if defined(SIZEOF_INT) #if SIZEOF_INT == 2 - pack_real_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_INT == 4 - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #elif defined(UINT_MAX) #if UINT_MAX == 0xffffU - pack_real_uint16(d); + pack_imp_uint16(d); #elif UINT_MAX == 0xffffffffU - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #else if(sizeof(unsigned int) == 2) { - pack_real_uint16(d); + pack_imp_uint16(d); } else if(sizeof(unsigned int) == 4) { - pack_real_uint32(d); + pack_imp_uint32(d); } else { - pack_real_uint64(d); + pack_imp_uint64(d); } #endif return *this; @@ -490,29 +490,29 @@ inline packer& packer::pack_unsigned_long(unsigned long d) { #if defined(SIZEOF_LONG) #if SIZEOF_LONG == 2 - pack_real_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_LONG == 4 - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #elif defined(ULONG_MAX) #if ULONG_MAX == 0xffffUL - pack_real_uint16(d); + pack_imp_uint16(d); #elif ULONG_MAX == 0xffffffffUL - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #else if(sizeof(unsigned long) == 2) { - pack_real_uint16(d); + pack_imp_uint16(d); } else if(sizeof(unsigned long) == 4) { - pack_real_uint32(d); + pack_imp_uint32(d); } else { - pack_real_uint64(d); + pack_imp_uint64(d); } #endif return *this; @@ -523,29 +523,29 @@ inline packer& packer::pack_unsigned_long_long(unsigned long lon { #if defined(SIZEOF_LONG_LONG) #if SIZEOF_LONG_LONG == 2 - pack_real_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_LONG_LONG == 4 - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #elif defined(ULLONG_MAX) #if ULLONG_MAX == 0xffffUL - pack_real_uint16(d); + pack_imp_uint16(d); #elif ULLONG_MAX == 0xffffffffUL - pack_real_uint32(d); + pack_imp_uint32(d); #else - pack_real_uint64(d); + pack_imp_uint64(d); #endif #else if(sizeof(unsigned long long) == 2) { - pack_real_uint16(d); + pack_imp_uint16(d); } else if(sizeof(unsigned long long) == 4) { - pack_real_uint32(d); + pack_imp_uint32(d); } else { - pack_real_uint64(d); + pack_imp_uint64(d); } #endif return *this; @@ -670,7 +670,7 @@ inline packer& packer::pack_raw_body(const char* b, size_t l) template template -inline void packer::pack_real_uint8(T d) +inline void packer::pack_imp_uint8(T d) { if(d < (1<<7)) { /* fixnum */ @@ -685,7 +685,7 @@ inline void packer::pack_real_uint8(T d) template template -inline void packer::pack_real_uint16(T d) +inline void packer::pack_imp_uint16(T d) { if(d < (1<<7)) { /* fixnum */ @@ -705,7 +705,7 @@ inline void packer::pack_real_uint16(T d) template template -inline void packer::pack_real_uint32(T d) +inline void packer::pack_imp_uint32(T d) { if(d < (1<<8)) { if(d < (1<<7)) { @@ -734,7 +734,7 @@ inline void packer::pack_real_uint32(T d) template template -inline void packer::pack_real_uint64(T d) +inline void packer::pack_imp_uint64(T d) { if(d < (1ULL<<8)) { if(d < (1ULL<<7)) { @@ -768,7 +768,7 @@ inline void packer::pack_real_uint64(T d) template template -inline void packer::pack_real_int8(T d) +inline void packer::pack_imp_int8(T d) { if(d < -(1<<5)) { /* signed 8 */ @@ -783,7 +783,7 @@ inline void packer::pack_real_int8(T d) template template -inline void packer::pack_real_int16(T d) +inline void packer::pack_imp_int16(T d) { if(d < -(1<<5)) { if(d < -(1<<7)) { @@ -816,7 +816,7 @@ inline void packer::pack_real_int16(T d) template template -inline void packer::pack_real_int32(T d) +inline void packer::pack_imp_int32(T d) { if(d < -(1<<5)) { if(d < -(1<<15)) { @@ -859,7 +859,7 @@ inline void packer::pack_real_int32(T d) template template -inline void packer::pack_real_int64(T d) +inline void packer::pack_imp_int64(T d) { if(d < -(1LL<<5)) { if(d < -(1LL<<15)) { From 415b14335fc62bc0d7339ffa1ea307c6d0982bb2 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 10:17:45 +0900 Subject: [PATCH 024/153] Modified the parameter of object::convert() from pointer to reference. --- cpp11/define.hpp | 4 +- cpp11/tuple.hpp | 4 +- src/msgpack/object.hpp | 13 ++++- src/msgpack/type/define.hpp.erb | 2 +- src/msgpack/type/deque.hpp | 2 +- src/msgpack/type/list.hpp | 2 +- src/msgpack/type/map.hpp | 14 +++--- src/msgpack/type/nil.hpp | 2 +- src/msgpack/type/pair.hpp | 4 +- src/msgpack/type/tr1/unordered_map.hpp | 8 +-- src/msgpack/type/tuple.hpp.erb | 12 ++--- src/msgpack/type/vector.hpp | 2 +- test/convert.cc | 6 +-- test/fixint.cc | 2 +- test/msgpack_test.cpp | 68 +++++++++++++------------- test/object.cc | 2 +- 16 files changed, 78 insertions(+), 69 deletions(-) diff --git a/cpp11/define.hpp b/cpp11/define.hpp index 9804aa1d..b29eb600 100644 --- a/cpp11/define.hpp +++ b/cpp11/define.hpp @@ -75,7 +75,7 @@ struct define_imp { define_imp::unpack(o, t); const size_t size = o.via.array.size; if(size <= N-1) { return; } - o.via.array.ptr[N-1].convert(&std::get(t)); + o.via.array.ptr[N-1].convert(std::get(t)); } static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { define_imp::object(o, z, t); @@ -92,7 +92,7 @@ struct define_imp { static void unpack(msgpack::object const& o, Tuple& t) { const size_t size = o.via.array.size; if(size <= 0) { return; } - o.via.array.ptr[0].convert(&std::get<0>(t)); + o.via.array.ptr[0].convert(std::get<0>(t)); } static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z); diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index 0ef661f5..54724489 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -141,7 +141,7 @@ struct Converter { object const& o, Tuple& v) { Converter::convert(o, v); - o.via.array.ptr[N-1].convert(v))>::type>(&type::get(v)); + o.via.array.ptr[N-1].convert(v))>::type>(type::get(v)); } }; @@ -150,7 +150,7 @@ struct Converter { static void convert ( object const& o, Tuple& v) { - o.via.array.ptr[0].convert(v))>::type>(&type::get<0>(v)); + o.via.array.ptr[0].convert(v))>::type>(type::get<0>(v)); } }; diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 6042d6c6..b5bf2848 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -85,9 +85,12 @@ struct object { template T as() const; + template + void convert(T& v) const; template void convert(T* v) const; + object(); object(msgpack_object o); @@ -302,17 +305,23 @@ inline object::implicit_type object::convert() const return implicit_type(*this); } +template +inline void object::convert(T& v) const +{ + *this >> v; +} + template inline void object::convert(T* v) const { - *this >> *v; + convert(*v); } template inline T object::as() const { T v; - convert(&v); + convert(v); return v; } diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb index 905b4496..bf1f4226 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/src/msgpack/type/define.hpp.erb @@ -111,7 +111,7 @@ struct define, A<%=j%><%}%>> { msgpack::object *ptr = o.via.array.ptr; switch(size) { default:<%(i).downto(0) {|j|%> - case <%=j+1%>: ptr[<%=j%>].convert(&a<%=j%>);<%}%> + case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%> } } } diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp index cf816498..878f5d5b 100644 --- a/src/msgpack/type/deque.hpp +++ b/src/msgpack/type/deque.hpp @@ -33,7 +33,7 @@ inline std::deque& operator>> (object o, std::deque& v) object* const pend = o.via.array.ptr + o.via.array.size; typename std::deque::iterator it = v.begin(); for(; p < pend; ++p, ++it) { - p->convert(&*it); + p->convert(*it); } return v; } diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp index 9367719e..eacad035 100644 --- a/src/msgpack/type/list.hpp +++ b/src/msgpack/type/list.hpp @@ -33,7 +33,7 @@ inline std::list& operator>> (object o, std::list& v) object* const pend = o.via.array.ptr + o.via.array.size; typename std::list::iterator it = v.begin(); for(; p < pend; ++p, ++it) { - p->convert(&*it); + p->convert(*it); } return v; } diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp index 589cff38..84f6237c 100644 --- a/src/msgpack/type/map.hpp +++ b/src/msgpack/type/map.hpp @@ -51,8 +51,8 @@ inline type::assoc_vector& operator>> (object o, type::assoc_vector& v object_kv* const pend = o.via.map.ptr + o.via.map.size; std::pair* it(&v.front()); for(; p < pend; ++p, ++it) { - p->key.convert(&it->first); - p->val.convert(&it->second); + p->key.convert(it->first); + p->val.convert(it->second); } std::sort(v.begin(), v.end(), type::detail::pair_first_less()); return v; @@ -101,13 +101,13 @@ inline std::map operator>> (object o, std::map& v) object_kv* const pend(o.via.map.ptr + o.via.map.size); for(; p != pend; ++p) { K key; - p->key.convert(&key); + p->key.convert(key); typename std::map::iterator it(v.lower_bound(key)); if(it != v.end() && !(key < it->first)) { - p->val.convert(&it->second); + p->val.convert(it->second); } else { V val; - p->val.convert(&val); + p->val.convert(val); v.insert(it, std::pair(key, val)); } } @@ -157,8 +157,8 @@ inline std::multimap operator>> (object o, std::multimap& v) object_kv* const pend(o.via.map.ptr + o.via.map.size); for(; p != pend; ++p) { std::pair value; - p->key.convert(&value.first); - p->val.convert(&value.second); + p->key.convert(value.first); + p->val.convert(value.second); v.insert(value); } return v; diff --git a/src/msgpack/type/nil.hpp b/src/msgpack/type/nil.hpp index 1b69f3c1..209bd390 100644 --- a/src/msgpack/type/nil.hpp +++ b/src/msgpack/type/nil.hpp @@ -55,7 +55,7 @@ template <> inline void object::as() const { msgpack::type::nil v; - convert(&v); + convert(v); } diff --git a/src/msgpack/type/pair.hpp b/src/msgpack/type/pair.hpp index f8ff85a6..87952365 100644 --- a/src/msgpack/type/pair.hpp +++ b/src/msgpack/type/pair.hpp @@ -29,8 +29,8 @@ inline std::pair& operator>> (object o, std::pair& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size != 2) { throw type_error(); } - o.via.array.ptr[0].convert(&v.first); - o.via.array.ptr[1].convert(&v.second); + o.via.array.ptr[0].convert(v.first); + o.via.array.ptr[1].convert(v.second); return v; } diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp index bb2623ff..23168f4e 100644 --- a/src/msgpack/type/tr1/unordered_map.hpp +++ b/src/msgpack/type/tr1/unordered_map.hpp @@ -51,8 +51,8 @@ inline MSGPACK_STD_TR1::unordered_map operator>> (object o, MSGPACK_STD_TR object_kv* const pend(o.via.map.ptr + o.via.map.size); for(; p != pend; ++p) { K key; - p->key.convert(&key); - p->val.convert(&v[key]); + p->key.convert(key); + p->val.convert(v[key]); } return v; } @@ -100,8 +100,8 @@ inline MSGPACK_STD_TR1::unordered_multimap operator>> (object o, MSGPACK_S object_kv* const pend(o.via.map.ptr + o.via.map.size); for(; p != pend; ++p) { std::pair value; - p->key.convert(&value.first); - p->val.convert(&value.second); + p->key.convert(value.first); + p->val.convert(value.second); v.insert(value); } return v; diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index cc0f1ea9..bf9cf8e0 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -1,7 +1,7 @@ // // MessagePack for C++ static resolution routine // -// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -92,7 +92,7 @@ private: template <> struct tuple<> { tuple() {} - tuple(object const& o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } typedef tuple<> value_type; }; <%0.upto(GENERATION_LIMIT) {|i|%> @@ -102,7 +102,7 @@ struct tuple, A<%=j%><%}%>> { tuple() {} tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - tuple(object const& o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -111,10 +111,10 @@ struct tuple, A<%=j%><%}%>> { A<%=j%> a<%=j%>;<%}%> }; -template , typename A<%=j%><%}%>> +template , typename A<%=j%><%}%>> inline typename type::tuple_element, A<%=j%><%}%>>, N>::reference get(type::tuple, A<%=j%><%}%>>& t) { return t.get(); } -template , typename A<%=j%><%}%>> +template , typename A<%=j%><%}%>> inline typename type::const_tuple_element, A<%=j%><%}%>>, N>::const_reference get(type::tuple, A<%=j%><%}%>> const& t) { return t.get(); } <%}%> @@ -147,7 +147,7 @@ type::tuple, A<%=j%><%}%>>& operator>> ( if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < <%=i+1%>) { throw type_error(); } <%0.upto(i) {|j|%> - o.via.array.ptr[<%=j%>].convert>::type>(&v.template get<<%=j%>>());<%}%> + o.via.array.ptr[<%=j%>].convert>::type>(v.template get<<%=j%>>());<%}%> return v; } <%}%> diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp index 338eb8c0..ce1604ec 100644 --- a/src/msgpack/type/vector.hpp +++ b/src/msgpack/type/vector.hpp @@ -34,7 +34,7 @@ inline std::vector& operator>> (object o, std::vector& v) object* const pend = o.via.array.ptr + o.via.array.size; T* it = &v[0]; do { - p->convert(it); + p->convert(*it); ++p; ++it; } while(p < pend); diff --git a/test/convert.cc b/test/convert.cc index f579f33a..e875b749 100644 --- a/test/convert.cc +++ b/test/convert.cc @@ -20,7 +20,7 @@ TEST(convert, compatibility_less) msgpack::object obj(src, &z); compatibility c; - EXPECT_NO_THROW( obj.convert(&c) ); + EXPECT_NO_THROW( obj.convert(c) ); EXPECT_EQ("kumofs", c.str1); EXPECT_EQ("default", c.str2); @@ -37,7 +37,7 @@ TEST(convert, compatibility_more) msgpack::object obj(src, &z); compatibility to; - EXPECT_NO_THROW( obj.convert(&to) ); + EXPECT_NO_THROW( obj.convert(to) ); EXPECT_EQ("kumofs", to.str1); EXPECT_EQ("mpio", to.str2); @@ -69,7 +69,7 @@ TEST(convert, enum_member) msgpack::object obj(src, &z); enum_member to; - EXPECT_NO_THROW( obj.convert(&to) ); + EXPECT_NO_THROW( obj.convert(to) ); EXPECT_EQ(enum_member::B, to.flag); } diff --git a/test/fixint.cc b/test/fixint.cc index a45edb90..a68d759a 100644 --- a/test/fixint.cc +++ b/test/fixint.cc @@ -33,7 +33,7 @@ void check_convert() { msgpack::unpack(msg, sbuf.data(), sbuf.size()); T v2; - msg.get().convert(&v2); + msg.get().convert(v2); EXPECT_EQ(v1.get(), v2.get()); diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 5e23e51c..37904952 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -41,7 +41,7 @@ const double kEPS = 1e-10; msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ - obj.convert(&val2); \ + obj.convert(val2); \ EXPECT_EQ(val1, val2); \ } \ } while(0) @@ -168,7 +168,7 @@ TEST(MSGPACK, simple_buffer_float) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float val2; - obj.convert(&val2); + obj.convert(val2); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -213,7 +213,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float_type val2; obj.convert(&val2); @@ -258,7 +258,7 @@ TEST(MSGPACK, simple_buffer_double) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); double val2; - obj.convert(&val2); + obj.convert(val2); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -280,7 +280,7 @@ TEST(MSGPACK, simple_buffer_true) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1, val2); } @@ -295,7 +295,7 @@ TEST(MSGPACK, simple_buffer_false) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1, val2); } @@ -317,7 +317,7 @@ TEST(MSGPACK_STL, simple_buffer_string) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); string val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1, val2); } @@ -337,7 +337,7 @@ TEST(MSGPACK_STL, simple_buffer_vector) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); vector val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -357,7 +357,7 @@ TEST(MSGPACK_STL, simple_buffer_map) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); map val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -377,7 +377,7 @@ TEST(MSGPACK_STL, simple_buffer_deque) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); deque val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -397,7 +397,7 @@ TEST(MSGPACK_STL, simple_buffer_list) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); list val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -417,7 +417,7 @@ TEST(MSGPACK_STL, simple_buffer_set) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); set val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -435,7 +435,7 @@ TEST(MSGPACK_STL, simple_buffer_pair) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); pair val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.second, val2.second); } @@ -458,7 +458,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multimap val2; - obj.convert(&val2); + obj.convert(val2); vector > v1, v2; multimap::const_iterator it; @@ -488,7 +488,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multiset val2; - obj.convert(&val2); + obj.convert(val2); vector v1, v2; multiset::const_iterator it; @@ -523,7 +523,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_map val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); tr1::unordered_map::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) { @@ -550,7 +550,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multimap val2; - obj.convert(&val2); + obj.convert(val2); vector > v1, v2; tr1::unordered_multimap::const_iterator it; @@ -584,7 +584,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_set val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.size(), val2.size()); tr1::unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) @@ -606,7 +606,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multiset val2; - obj.convert(&val2); + obj.convert(val2); vector v1, v2; tr1::unordered_multiset::const_iterator it; @@ -637,7 +637,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_map val2; obj.convert(&val2); @@ -664,7 +664,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_multimap val2; obj.convert(&val2); @@ -698,7 +698,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_set val2; obj.convert(&val2); @@ -720,7 +720,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_multiset val2; obj.convert(&val2); @@ -765,7 +765,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) TestClass val2; val2.i = -1; val2.s = ""; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); } @@ -799,7 +799,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) val2.i = -1; val2.s = ""; val2.v = vector(); - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); @@ -820,7 +820,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) TestClass val2; val2.i = -1; val2.s = ""; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); @@ -862,7 +862,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) val2.t1 = TestEnumMemberClass::STATE_INVALID; val2.t2 = TestEnumMemberClass::STATE_INVALID; val2.t3 = TestEnumMemberClass::STATE_INVALID; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); @@ -899,13 +899,13 @@ public: void msgpack_unpack(msgpack::object o) { msgpack::type::tuple tuple; - o.convert(&tuple); + o.convert(tuple); is_double = msgpack::type::get<0>(tuple); if (is_double) - msgpack::type::get<1>(tuple).convert(&value.f); + msgpack::type::get<1>(tuple).convert(value.f); else - msgpack::type::get<1>(tuple).convert(&value.i); + msgpack::type::get<1>(tuple).convert(value.i); } }; @@ -922,7 +922,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); } @@ -937,7 +937,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; - obj.convert(&val2); + obj.convert(val2); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.value.i, 1); EXPECT_EQ(val1.value.i, val2.value.i); @@ -965,7 +965,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ - obj.convert(&val2); \ + obj.convert(val2); \ EXPECT_EQ(val1, val2); \ } \ } while(0); @@ -1094,7 +1094,7 @@ TEST(MSGPACK, vrefbuffer_int64) EXPECT_TRUE(life != NULL); \ pac.reset(); \ vec_type::value_type val; \ - obj.convert(&val); \ + obj.convert(val); \ EXPECT_EQ(*it, val); \ ++it; \ msgpack::zone::destroy(life); \ diff --git a/test/object.cc b/test/object.cc index 7a6b0a87..8916538c 100644 --- a/test/object.cc +++ b/test/object.cc @@ -41,7 +41,7 @@ TEST(object, convert) EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); myclass m2; - obj.convert(&m2); + obj.convert(m2); EXPECT_EQ(m1, m2); } From 616be1aa60a99c83f52e84dcd5e448bd0773dc31 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 10:49:34 +0900 Subject: [PATCH 025/153] Modified type classes' interfaces parameters 'object' from passed by value to passed by reference. --- src/msgpack/type/bool.hpp | 2 +- src/msgpack/type/deque.hpp | 2 +- src/msgpack/type/fixint.hpp | 16 ++++++++-------- src/msgpack/type/float.hpp | 4 ++-- src/msgpack/type/int.hpp | 24 ++++++++++++------------ src/msgpack/type/list.hpp | 2 +- src/msgpack/type/map.hpp | 6 +++--- src/msgpack/type/nil.hpp | 2 +- src/msgpack/type/pair.hpp | 2 +- src/msgpack/type/raw.hpp | 2 +- src/msgpack/type/set.hpp | 4 ++-- src/msgpack/type/string.hpp | 2 +- src/msgpack/type/vector.hpp | 2 +- 13 files changed, 35 insertions(+), 35 deletions(-) diff --git a/src/msgpack/type/bool.hpp b/src/msgpack/type/bool.hpp index c689f643..06dd3477 100644 --- a/src/msgpack/type/bool.hpp +++ b/src/msgpack/type/bool.hpp @@ -24,7 +24,7 @@ namespace msgpack { -inline bool& operator>> (object o, bool& v) +inline bool& operator>> (object const& o, bool& v) { if(o.type != type::BOOLEAN) { throw type_error(); } v = o.via.boolean; diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp index 878f5d5b..a7c57b03 100644 --- a/src/msgpack/type/deque.hpp +++ b/src/msgpack/type/deque.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::deque& operator>> (object o, std::deque& v) +inline std::deque& operator>> (object const& o, std::deque& v) { if(o.type != type::ARRAY) { throw type_error(); } v.resize(o.via.array.size); diff --git a/src/msgpack/type/fixint.hpp b/src/msgpack/type/fixint.hpp index 4f0289da..e68a83ad 100644 --- a/src/msgpack/type/fixint.hpp +++ b/src/msgpack/type/fixint.hpp @@ -54,29 +54,29 @@ typedef fix_int fix_int64; } // namespace type -inline type::fix_int8& operator>> (object o, type::fix_int8& v) +inline type::fix_int8& operator>> (object const& o, type::fix_int8& v) { v = type::detail::convert_integer(o); return v; } -inline type::fix_int16& operator>> (object o, type::fix_int16& v) +inline type::fix_int16& operator>> (object const& o, type::fix_int16& v) { v = type::detail::convert_integer(o); return v; } -inline type::fix_int32& operator>> (object o, type::fix_int32& v) +inline type::fix_int32& operator>> (object const& o, type::fix_int32& v) { v = type::detail::convert_integer(o); return v; } -inline type::fix_int64& operator>> (object o, type::fix_int64& v) +inline type::fix_int64& operator>> (object const& o, type::fix_int64& v) { v = type::detail::convert_integer(o); return v; } -inline type::fix_uint8& operator>> (object o, type::fix_uint8& v) +inline type::fix_uint8& operator>> (object const& o, type::fix_uint8& v) { v = type::detail::convert_integer(o); return v; } -inline type::fix_uint16& operator>> (object o, type::fix_uint16& v) +inline type::fix_uint16& operator>> (object const& o, type::fix_uint16& v) { v = type::detail::convert_integer(o); return v; } -inline type::fix_uint32& operator>> (object o, type::fix_uint32& v) +inline type::fix_uint32& operator>> (object const& o, type::fix_uint32& v) { v = type::detail::convert_integer(o); return v; } -inline type::fix_uint64& operator>> (object o, type::fix_uint64& v) +inline type::fix_uint64& operator>> (object const& o, type::fix_uint64& v) { v = type::detail::convert_integer(o); return v; } diff --git a/src/msgpack/type/float.hpp b/src/msgpack/type/float.hpp index 823757cd..fbbe8aed 100644 --- a/src/msgpack/type/float.hpp +++ b/src/msgpack/type/float.hpp @@ -27,7 +27,7 @@ namespace msgpack { // FIXME check overflow, underflow -inline float& operator>> (object o, float& v) +inline float& operator>> (object const& o, float& v) { if(o.type == type::DOUBLE) { v = (float)o.via.dec; @@ -52,7 +52,7 @@ inline packer& operator<< (packer& o, const float& v) } -inline double& operator>> (object o, double& v) +inline double& operator>> (object const& o, double& v) { if(o.type == type::DOUBLE) { v = o.via.dec; diff --git a/src/msgpack/type/int.hpp b/src/msgpack/type/int.hpp index 5286f010..5fa638fd 100644 --- a/src/msgpack/type/int.hpp +++ b/src/msgpack/type/int.hpp @@ -31,7 +31,7 @@ namespace detail { template struct convert_integer_sign { - static inline T convert(object o) { + static inline T convert(object const& o) { if(o.type == type::POSITIVE_INTEGER) { if(o.via.u64 > (uint64_t)std::numeric_limits::max()) { throw type_error(); } @@ -47,7 +47,7 @@ namespace detail { template struct convert_integer_sign { - static inline T convert(object o) { + static inline T convert(object const& o) { if(o.type == type::POSITIVE_INTEGER) { if(o.via.u64 > (uint64_t)std::numeric_limits::max()) { throw type_error(); } @@ -121,35 +121,35 @@ inline char& operator>> (object const& o, char& v) { v = type::detail::convert_integer(o); return v; } -inline signed char& operator>> (object o, signed char& v) +inline signed char& operator>> (object const& o, signed char& v) { v = type::detail::convert_integer(o); return v; } -inline signed short& operator>> (object o, signed short& v) +inline signed short& operator>> (object const& o, signed short& v) { v = type::detail::convert_integer(o); return v; } -inline signed int& operator>> (object o, signed int& v) +inline signed int& operator>> (object const& o, signed int& v) { v = type::detail::convert_integer(o); return v; } -inline signed long& operator>> (object o, signed long& v) +inline signed long& operator>> (object const& o, signed long& v) { v = type::detail::convert_integer(o); return v; } -inline signed long long& operator>> (object o, signed long long& v) +inline signed long long& operator>> (object const& o, signed long long& v) { v = type::detail::convert_integer(o); return v; } -inline unsigned char& operator>> (object o, unsigned char& v) +inline unsigned char& operator>> (object const& o, unsigned char& v) { v = type::detail::convert_integer(o); return v; } -inline unsigned short& operator>> (object o, unsigned short& v) +inline unsigned short& operator>> (object const& o, unsigned short& v) { v = type::detail::convert_integer(o); return v; } -inline unsigned int& operator>> (object o, unsigned int& v) +inline unsigned int& operator>> (object const& o, unsigned int& v) { v = type::detail::convert_integer(o); return v; } -inline unsigned long& operator>> (object o, unsigned long& v) +inline unsigned long& operator>> (object const& o, unsigned long& v) { v = type::detail::convert_integer(o); return v; } -inline unsigned long long& operator>> (object o, unsigned long long& v) +inline unsigned long long& operator>> (object const& o, unsigned long long& v) { v = type::detail::convert_integer(o); return v; } template diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp index eacad035..30f78d62 100644 --- a/src/msgpack/type/list.hpp +++ b/src/msgpack/type/list.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::list& operator>> (object o, std::list& v) +inline std::list& operator>> (object const& o, std::list& v) { if(o.type != type::ARRAY) { throw type_error(); } v.resize(o.via.array.size); diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp index 84f6237c..39d64a08 100644 --- a/src/msgpack/type/map.hpp +++ b/src/msgpack/type/map.hpp @@ -43,7 +43,7 @@ namespace detail { template -inline type::assoc_vector& operator>> (object o, type::assoc_vector& v) +inline type::assoc_vector& operator>> (object const& o, type::assoc_vector& v) { if(o.type != type::MAP) { throw type_error(); } v.resize(o.via.map.size); @@ -94,7 +94,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector& v) template -inline std::map operator>> (object o, std::map& v) +inline std::map operator>> (object const& o, std::map& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -150,7 +150,7 @@ inline void operator<< (object::with_zone& o, const std::map& v) template -inline std::multimap operator>> (object o, std::multimap& v) +inline std::multimap operator>> (object const& o, std::multimap& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); diff --git a/src/msgpack/type/nil.hpp b/src/msgpack/type/nil.hpp index 209bd390..03b9945e 100644 --- a/src/msgpack/type/nil.hpp +++ b/src/msgpack/type/nil.hpp @@ -29,7 +29,7 @@ struct nil { }; } // namespace type -inline type::nil& operator>> (object o, type::nil& v) +inline type::nil& operator>> (object const& o, type::nil& v) { if(o.type != type::NIL) { throw type_error(); } return v; diff --git a/src/msgpack/type/pair.hpp b/src/msgpack/type/pair.hpp index 87952365..1b9611e4 100644 --- a/src/msgpack/type/pair.hpp +++ b/src/msgpack/type/pair.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::pair& operator>> (object o, std::pair& v) +inline std::pair& operator>> (object const& o, std::pair& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size != 2) { throw type_error(); } diff --git a/src/msgpack/type/raw.hpp b/src/msgpack/type/raw.hpp index 0f296236..efe2d21c 100644 --- a/src/msgpack/type/raw.hpp +++ b/src/msgpack/type/raw.hpp @@ -61,7 +61,7 @@ struct raw_ref { } // namespace type -inline type::raw_ref& operator>> (object o, type::raw_ref& v) +inline type::raw_ref& operator>> (object const& o, type::raw_ref& v) { if(o.type != type::RAW) { throw type_error(); } v.ptr = o.via.raw.ptr; diff --git a/src/msgpack/type/set.hpp b/src/msgpack/type/set.hpp index 065e69a6..9b862131 100644 --- a/src/msgpack/type/set.hpp +++ b/src/msgpack/type/set.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::set& operator>> (object o, std::set& v) +inline std::set& operator>> (object const& o, std::set& v) { if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; @@ -71,7 +71,7 @@ inline void operator<< (object::with_zone& o, const std::set& v) template -inline std::multiset& operator>> (object o, std::multiset& v) +inline std::multiset& operator>> (object const& o, std::multiset& v) { if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index e7839472..4dfe35c8 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -24,7 +24,7 @@ namespace msgpack { -inline std::string& operator>> (object o, std::string& v) +inline std::string& operator>> (object const& o, std::string& v) { if(o.type != type::RAW) { throw type_error(); } v.assign(o.via.raw.ptr, o.via.raw.size); diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp index ce1604ec..4cd1597e 100644 --- a/src/msgpack/type/vector.hpp +++ b/src/msgpack/type/vector.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::vector& operator>> (object o, std::vector& v) +inline std::vector& operator>> (object const& o, std::vector& v) { if(o.type != type::ARRAY) { throw type_error(); } v.resize(o.via.array.size); From 9bd339baf8d8046db068ae47613b686ab83a1601 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 11:31:03 +0900 Subject: [PATCH 026/153] Restored pointer based interfaces to maintain compatibility. --- src/msgpack/object.hpp | 1 - src/msgpack/unpack.hpp | 33 ++++++++++++++++++++++++++++----- 2 files changed, 28 insertions(+), 6 deletions(-) diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index b5bf2848..51bbd987 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -90,7 +90,6 @@ struct object { template void convert(T* v) const; - object(); object(msgpack_object o); diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 694b75c4..ec129f8a 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -670,25 +670,29 @@ private: }; -static void unpack(unpacked& result, +inline void unpack(unpacked& result, + const char* data, size_t len, size_t* offset = NULL); +inline void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL); - // obsolete typedef enum { UNPACK_SUCCESS = 2, UNPACK_EXTRA_BYTES = 1, - UNPACK_CONTINUE = 0, + UNPACK_CONTINUE = 0, UNPACK_PARSE_ERROR = -1, } unpack_return; // obsolete static unpack_return unpack(const char* data, size_t len, size_t* off, zone& z, object& result); +static unpack_return unpack(const char* data, size_t len, size_t* off, + zone* z, object* result); // obsolete static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL); +static object unpack(const char* data, size_t len, zone* z, size_t* off = NULL); inline unpacker::unpacker(size_t initial_buffer_size) @@ -943,7 +947,7 @@ namespace detail { inline unpack_return unpack_imp(const char* data, size_t len, size_t* off, - zone& result_zone, object& result) + zone& result_zone, object& result) { size_t noff = 0; if(off != NULL) { noff = *off; } @@ -981,8 +985,9 @@ unpack_imp(const char* data, size_t len, size_t* off, } // detail +// reference version inline void unpack(unpacked& result, - const char* data, size_t len, size_t* offset) + const char* data, size_t len, size_t* offset) { object obj; msgpack::unique_ptr z(new zone()); @@ -1010,17 +1015,30 @@ inline void unpack(unpacked& result, throw unpack_error("parse error"); } } +// pointer version +inline void unpack(unpacked* result, + const char* data, size_t len, size_t* offset) { + unpack(*result, data, len, offset); +} // obsolete +// reference version inline unpack_return unpack(const char* data, size_t len, size_t* off, zone& z, object& result) { return detail::unpack_imp(data, len, off, z, result); } +// pointer version +inline unpack_return unpack(const char* data, size_t len, size_t* off, + zone* z, object* result) +{ + return unpack(data, len, off, *z, *result); +} // obsolete +// reference version inline object unpack(const char* data, size_t len, zone& z, size_t* off) { object result; @@ -1044,6 +1062,11 @@ inline object unpack(const char* data, size_t len, zone& z, size_t* off) throw unpack_error("parse error"); } } +// pointer version +inline object unpack(const char* data, size_t len, zone* z, size_t* off) +{ + return unpack(data, len, *z, off); +} } // namespace msgpack From 4ef69da25dd719718fbaf7a454ba4961a21c73cc Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 11:42:32 +0900 Subject: [PATCH 027/153] Restored the test cases using pointer based interfaces. It assures that we can use the same interfaces as the original version(0.5.6). To support both C++03 and C++11, I introduced msgpack::unique_ptr and msgpack::move() in test codes. --- example/speed_test.cc | 13 ++++- test/convert.cc | 6 +-- test/fixint.cc | 4 +- test/msgpack_test.cpp | 110 +++++++++++++++++++++--------------------- test/object.cc | 6 +-- test/pack_unpack.cc | 14 +++--- 6 files changed, 81 insertions(+), 72 deletions(-) diff --git a/example/speed_test.cc b/example/speed_test.cc index 589fbe40..1758ad5b 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -31,7 +31,7 @@ void test_map_pack_unpack() { std::cout << "Start unpacking..." << std::endl; { boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, mempool, deserialized); + msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); std::string result = timer.format(); std::cout << result << std::endl; } @@ -41,11 +41,20 @@ void test_map_pack_unpack() { std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; { boost::timer::cpu_timer timer; - msgpack::unpack(unpacked, str.data(), str.size()); + msgpack::unpack(&unpacked, str.data(), str.size()); std::string result = timer.format(); std::cout << result << std::endl; } std::cout << "Unpack finished..." << std::endl; + std::map m2; + std::cout << "Start converting..." << std::endl; + { + boost::timer::cpu_timer timer; + deserialized.convert(&m2); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Convert finished..." << std::endl; } diff --git a/test/convert.cc b/test/convert.cc index e875b749..f579f33a 100644 --- a/test/convert.cc +++ b/test/convert.cc @@ -20,7 +20,7 @@ TEST(convert, compatibility_less) msgpack::object obj(src, &z); compatibility c; - EXPECT_NO_THROW( obj.convert(c) ); + EXPECT_NO_THROW( obj.convert(&c) ); EXPECT_EQ("kumofs", c.str1); EXPECT_EQ("default", c.str2); @@ -37,7 +37,7 @@ TEST(convert, compatibility_more) msgpack::object obj(src, &z); compatibility to; - EXPECT_NO_THROW( obj.convert(to) ); + EXPECT_NO_THROW( obj.convert(&to) ); EXPECT_EQ("kumofs", to.str1); EXPECT_EQ("mpio", to.str2); @@ -69,7 +69,7 @@ TEST(convert, enum_member) msgpack::object obj(src, &z); enum_member to; - EXPECT_NO_THROW( obj.convert(to) ); + EXPECT_NO_THROW( obj.convert(&to) ); EXPECT_EQ(enum_member::B, to.flag); } diff --git a/test/fixint.cc b/test/fixint.cc index a68d759a..63288a1b 100644 --- a/test/fixint.cc +++ b/test/fixint.cc @@ -30,10 +30,10 @@ void check_convert() { msgpack::pack(sbuf, v1); msgpack::unpacked msg; - msgpack::unpack(msg, sbuf.data(), sbuf.size()); + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); T v2; - msg.get().convert(v2); + msg.get().convert(&v2); EXPECT_EQ(v1.get(), v2.get()); diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 37904952..d9a40500 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,10 +38,10 @@ const double kEPS = 1e-10; msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ - obj.convert(val2); \ + obj.convert(&val2); \ EXPECT_EQ(val1, val2); \ } \ } while(0) @@ -165,10 +165,10 @@ TEST(MSGPACK, simple_buffer_float) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float val2; - obj.convert(val2); + obj.convert(&val2); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -255,10 +255,10 @@ TEST(MSGPACK, simple_buffer_double) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); double val2; - obj.convert(val2); + obj.convert(&val2); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -277,10 +277,10 @@ TEST(MSGPACK, simple_buffer_true) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1, val2); } @@ -292,10 +292,10 @@ TEST(MSGPACK, simple_buffer_false) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1, val2); } @@ -314,10 +314,10 @@ TEST(MSGPACK_STL, simple_buffer_string) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); string val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1, val2); } @@ -334,10 +334,10 @@ TEST(MSGPACK_STL, simple_buffer_vector) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); vector val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -354,10 +354,10 @@ TEST(MSGPACK_STL, simple_buffer_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); map val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -374,10 +374,10 @@ TEST(MSGPACK_STL, simple_buffer_deque) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); deque val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -394,10 +394,10 @@ TEST(MSGPACK_STL, simple_buffer_list) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); list val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -414,10 +414,10 @@ TEST(MSGPACK_STL, simple_buffer_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); set val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -432,10 +432,10 @@ TEST(MSGPACK_STL, simple_buffer_pair) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); pair val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.second, val2.second); } @@ -455,10 +455,10 @@ TEST(MSGPACK_STL, simple_buffer_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multimap val2; - obj.convert(val2); + obj.convert(&val2); vector > v1, v2; multimap::const_iterator it; @@ -485,10 +485,10 @@ TEST(MSGPACK_STL, simple_buffer_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multiset val2; - obj.convert(val2); + obj.convert(&val2); vector v1, v2; multiset::const_iterator it; @@ -520,10 +520,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_map val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); tr1::unordered_map::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) { @@ -547,10 +547,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multimap val2; - obj.convert(val2); + obj.convert(&val2); vector > v1, v2; tr1::unordered_multimap::const_iterator it; @@ -581,10 +581,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_set val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.size(), val2.size()); tr1::unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) @@ -603,10 +603,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multiset val2; - obj.convert(val2); + obj.convert(&val2); vector v1, v2; tr1::unordered_multiset::const_iterator it; @@ -760,12 +760,12 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; val2.s = ""; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); } @@ -793,13 +793,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass2 val2; val2.i = -1; val2.s = ""; val2.v = vector(); - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); @@ -815,12 +815,12 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; val2.s = ""; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); @@ -856,13 +856,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestEnumMemberClass val2; val2.t1 = TestEnumMemberClass::STATE_INVALID; val2.t2 = TestEnumMemberClass::STATE_INVALID; val2.t3 = TestEnumMemberClass::STATE_INVALID; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); @@ -899,13 +899,13 @@ public: void msgpack_unpack(msgpack::object o) { msgpack::type::tuple tuple; - o.convert(tuple); + o.convert(&tuple); - is_double = msgpack::type::get<0>(tuple); + is_double = tuple.get<0>(); if (is_double) - msgpack::type::get<1>(tuple).convert(value.f); + tuple.get<1>().convert(&value.f); else - msgpack::type::get<1>(tuple).convert(value.i); + tuple.get<1>().convert(&value.i); } }; @@ -919,10 +919,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); } @@ -934,10 +934,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; - obj.convert(val2); + obj.convert(&val2); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.value.i, 1); EXPECT_EQ(val1.value.i, val2.value.i); @@ -962,10 +962,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ - obj.convert(val2); \ + obj.convert(&val2); \ EXPECT_EQ(val1, val2); \ } \ } while(0); @@ -1094,7 +1094,7 @@ TEST(MSGPACK, vrefbuffer_int64) EXPECT_TRUE(life != NULL); \ pac.reset(); \ vec_type::value_type val; \ - obj.convert(val); \ + obj.convert(&val); \ EXPECT_EQ(*it, val); \ ++it; \ msgpack::zone::destroy(life); \ diff --git a/test/object.cc b/test/object.cc index 8916538c..5390c4ae 100644 --- a/test/object.cc +++ b/test/object.cc @@ -37,11 +37,11 @@ TEST(object, convert) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); myclass m2; - obj.convert(m2); + obj.convert(&m2); EXPECT_EQ(m1, m2); } @@ -58,7 +58,7 @@ TEST(object, as) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(m1, obj.as()); diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index fd42bc4d..ac47f2d9 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -60,7 +60,7 @@ TEST(unpack, myclass) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); @@ -81,13 +81,13 @@ TEST(unpack, sequence) msgpack::unpacked msg; - msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); EXPECT_EQ(1, msg.get().as()); - msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); EXPECT_EQ(2, msg.get().as()); - msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); EXPECT_EQ(3, msg.get().as()); } @@ -105,17 +105,17 @@ TEST(unpack, sequence_compat) msgpack::object obj; msgpack::unpack_return ret; - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(1, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(2, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(3, obj.as()); From b6b2ef5e57292cada7e306d3b42f914578a8041f Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 13:08:05 +0900 Subject: [PATCH 028/153] Removed the last comma at enum definitions to support C++03 strictly. --- src/msgpack/object.h | 6 +++--- src/msgpack/object.hpp | 2 +- src/msgpack/unpack.h | 4 ++-- src/msgpack/unpack.hpp | 2 +- src/msgpack/unpack_define.h | 4 ++-- test/convert.cc | 2 +- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/msgpack/object.h b/src/msgpack/object.h index 86927c39..4e840486 100644 --- a/src/msgpack/object.h +++ b/src/msgpack/object.h @@ -35,12 +35,12 @@ extern "C" { typedef enum { MSGPACK_OBJECT_NIL = 0x00, MSGPACK_OBJECT_BOOLEAN = 0x01, - MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, - MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, + MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, + MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, MSGPACK_OBJECT_DOUBLE = 0x04, MSGPACK_OBJECT_RAW = 0x05, MSGPACK_OBJECT_ARRAY = 0x06, - MSGPACK_OBJECT_MAP = 0x07, + MSGPACK_OBJECT_MAP = 0x07 } msgpack_object_type; diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 51bbd987..42b0060f 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -42,7 +42,7 @@ namespace type { DOUBLE = MSGPACK_OBJECT_DOUBLE, RAW = MSGPACK_OBJECT_RAW, ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP, + MAP = MSGPACK_OBJECT_MAP }; } diff --git a/src/msgpack/unpack.h b/src/msgpack/unpack.h index c90e95af..92eb346b 100644 --- a/src/msgpack/unpack.h +++ b/src/msgpack/unpack.h @@ -178,8 +178,8 @@ static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac) typedef enum { MSGPACK_UNPACK_SUCCESS = 2, MSGPACK_UNPACK_EXTRA_BYTES = 1, - MSGPACK_UNPACK_CONTINUE = 0, - MSGPACK_UNPACK_PARSE_ERROR = -1, + MSGPACK_UNPACK_CONTINUE = 0, + MSGPACK_UNPACK_PARSE_ERROR = -1 } msgpack_unpack_return; // obsolete diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index ec129f8a..04450dc2 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -680,7 +680,7 @@ typedef enum { UNPACK_SUCCESS = 2, UNPACK_EXTRA_BYTES = 1, UNPACK_CONTINUE = 0, - UNPACK_PARSE_ERROR = -1, + UNPACK_PARSE_ERROR = -1 } unpack_return; // obsolete diff --git a/src/msgpack/unpack_define.h b/src/msgpack/unpack_define.h index 4c0b9c65..d9457940 100644 --- a/src/msgpack/unpack_define.h +++ b/src/msgpack/unpack_define.h @@ -76,14 +76,14 @@ typedef enum { //ACS_BIG_INT_VALUE, //ACS_BIG_FLOAT_VALUE, - ACS_RAW_VALUE, + ACS_RAW_VALUE } msgpack_unpack_state; typedef enum { CT_ARRAY_ITEM, CT_MAP_KEY, - CT_MAP_VALUE, + CT_MAP_VALUE } msgpack_container_type; diff --git a/test/convert.cc b/test/convert.cc index f579f33a..4572580f 100644 --- a/test/convert.cc +++ b/test/convert.cc @@ -50,7 +50,7 @@ public: enum flags_t { A = 0, - B = 1, + B = 1 }; flags_t flag; From 541ece13c0d43892aa5bca66b8a6ecd6c17b9db9 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 13:09:08 +0900 Subject: [PATCH 029/153] Added inline for constructors and a destructor. --- src/msgpack/pack.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index c18385fb..5b5b0460 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -161,13 +161,13 @@ inline char take8_64(T d) { #endif template -packer::packer(Stream* s) : m_stream(*s) { } +inline packer::packer(Stream* s) : m_stream(*s) { } template -packer::packer(Stream& s) : m_stream(s) { } +inline packer::packer(Stream& s) : m_stream(s) { } template -packer::~packer() { } +inline packer::~packer() { } template From c41154989a094f2107bcc4717fd45e5eae92a08f Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 13:18:51 +0900 Subject: [PATCH 030/153] Used the reference version of convert instead of pointer version. --- src/msgpack/object.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 42b0060f..be755eb1 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -378,7 +378,7 @@ inline object::operator msgpack_object() const template inline void convert(T& v, object const& o) { - o.convert(&v); + o.convert(v); } // obsolete From 4d2a9c23af8ae8ea8cd3e35c404bbe3d1740f76b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 13:20:21 +0900 Subject: [PATCH 031/153] Added inline keyword. --- src/msgpack/object.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index be755eb1..404e39d6 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -202,7 +202,7 @@ inline packer& operator<< (packer& o, const T& v) // deconvert operator template -void operator<< (object::with_zone& o, const T& v) +inline void operator<< (object::with_zone& o, const T& v) { v.msgpack_object(static_cast(&o), o.zone); } From b0b1a0e9a7197a3551726509e25813b7497e5c37 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 14:35:47 +0900 Subject: [PATCH 032/153] Removed template_callback_root. --- src/msgpack/unpack.hpp | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 04450dc2..19697f73 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -60,9 +60,6 @@ private: bool referenced_; }; -inline object template_callback_root(unpack_user&) -{ object o; return o; } - inline int template_callback_uint8(unpack_user&, uint8_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } @@ -192,7 +189,7 @@ class template_context { public: template_context():cs_(CS_HEADER), trail_(0), top_(0) { - stack_[0].setObj(template_callback_root(user_)); + stack_[0].setObj(object()); } void init() @@ -200,7 +197,7 @@ public: cs_ = CS_HEADER; trail_ = 0; top_ = 0; - stack_[0].setObj(template_callback_root(user_)); + stack_[0].setObj(object()); } object const& data() const From f8fc03b482db9f27dd735ea32b3e4411fcd1946d Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 14:52:45 +0900 Subject: [PATCH 033/153] Modified template functions' return value from int to bool. --- src/msgpack/unpack.hpp | 132 ++++++++++++++++++++--------------------- 1 file changed, 66 insertions(+), 66 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 19697f73..44eec64b 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -60,85 +60,85 @@ private: bool referenced_; }; -inline int template_callback_uint8(unpack_user&, uint8_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } +inline bool template_callback_uint8(unpack_user&, uint8_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } -inline int template_callback_uint16(unpack_user&, uint16_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } +inline bool template_callback_uint16(unpack_user&, uint16_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } -inline int template_callback_uint32(unpack_user&, uint32_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } +inline bool template_callback_uint32(unpack_user&, uint32_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } -inline int template_callback_uint64(unpack_user&, uint64_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } +inline bool template_callback_uint64(unpack_user&, uint64_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } -inline int template_callback_int8(unpack_user&, int8_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } +inline bool template_callback_int8(unpack_user&, int8_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } -inline int template_callback_int16(unpack_user&, int16_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } +inline bool template_callback_int16(unpack_user&, int16_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } -inline int template_callback_int32(unpack_user&, int32_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } +inline bool template_callback_int32(unpack_user&, int32_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } -inline int template_callback_int64(unpack_user&, int64_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return 0; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return 0; } } +inline bool template_callback_int64(unpack_user&, int64_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } -inline int template_callback_float(unpack_user&, float d, object& o) -{ o.type = type::DOUBLE; o.via.dec = d; return 0; } +inline bool template_callback_float(unpack_user&, float d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; return true; } -inline int template_callback_double(unpack_user&, double d, object& o) -{ o.type = type::DOUBLE; o.via.dec = d; return 0; } +inline bool template_callback_double(unpack_user&, double d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; return true; } -inline int template_callback_nil(unpack_user&, object& o) -{ o.type = type::NIL; return 0; } +inline bool template_callback_nil(unpack_user&, object& o) +{ o.type = type::NIL; return true; } -inline int template_callback_true(unpack_user&, object& o) -{ o.type = type::BOOLEAN; o.via.boolean = true; return 0; } +inline bool template_callback_true(unpack_user&, object& o) +{ o.type = type::BOOLEAN; o.via.boolean = true; return true; } -inline int template_callback_false(unpack_user&, object& o) -{ o.type = type::BOOLEAN; o.via.boolean = false; return 0; } +inline bool template_callback_false(unpack_user&, object& o) +{ o.type = type::BOOLEAN; o.via.boolean = false; return true; } -inline int template_callback_array(unpack_user&u, unsigned int n, object& o) +inline bool template_callback_array(unpack_user&u, unsigned int n, object& o) { o.type = type::ARRAY; o.via.array.size = 0; o.via.array.ptr = (object*)u.z().malloc(n*sizeof(object)); - if(o.via.array.ptr == NULL) { return -1; } - return 0; + if(o.via.array.ptr == NULL) { return false; } + return true; } -inline int template_callback_array_item(unpack_user&, object& c, object const& o) -{ c.via.array.ptr[c.via.array.size++] = o; return 0; } +inline bool template_callback_array_item(unpack_user&, object& c, object const& o) +{ c.via.array.ptr[c.via.array.size++] = o; return true; } -inline int template_callback_map(unpack_user& u, unsigned int n, object& o) +inline bool template_callback_map(unpack_user& u, unsigned int n, object& o) { o.type = type::MAP; o.via.map.size = 0; o.via.map.ptr = (object_kv*)u.z().malloc(n*sizeof(object_kv)); - if(o.via.map.ptr == NULL) { return -1; } - return 0; + if(o.via.map.ptr == NULL) { return false; } + return true; } -inline int template_callback_map_item(unpack_user&, object& c, object const& k, object const& v) +inline bool template_callback_map_item(unpack_user&, object& c, object const& k, object const& v) { c.via.map.ptr[c.via.map.size].key = k; c.via.map.ptr[c.via.map.size].val = v; ++c.via.map.size; - return 0; + return true; } -inline int template_callback_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) +inline bool template_callback_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) { o.type = type::RAW; o.via.raw.ptr = p; o.via.raw.size = l; u.set_referenced(true); - return 0; + return true; } @@ -240,23 +240,23 @@ public: case CS_HEADER: if (0) { } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum - if(template_callback_uint8(user_, *(uint8_t*)p, obj) < 0) { goto _failed; } + if(!template_callback_uint8(user_, *(uint8_t*)p, obj)) { goto _failed; } goto _push; } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum - if(template_callback_int8(user_, *(int8_t*)p, obj) < 0) { goto _failed; } + if(!template_callback_int8(user_, *(int8_t*)p, obj)) { goto _failed; } goto _push; } else if(0xc0 <= *p && *p <= 0xdf) { // Variable switch(*p) { case 0xc0: // nil - if(template_callback_nil(user_, obj) < 0) { goto _failed; } + if(!template_callback_nil(user_, obj)) { goto _failed; } goto _push; //case 0xc1: // string // again_terminal_trail(next_cs(p), p+1); case 0xc2: // false - if(template_callback_false(user_, obj) < 0) { goto _failed; } + if(!template_callback_false(user_, obj)) { goto _failed; } goto _push; case 0xc3: // true - if(template_callback_true(user_, obj) < 0) { goto _failed; } + if(!template_callback_true(user_, obj)) { goto _failed; } goto _push; case 0xc4: // bin 8 case 0xc5: // bin 16 @@ -310,7 +310,7 @@ public: } else if(0x90 <= *p && *p <= 0x9f) { // FixArray if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user_, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } + if(!template_callback_array(user_, ((unsigned int)*p) & 0x0f, stack[top].obj())) { goto _failed; } if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(((unsigned int)*p) & 0x0f); @@ -319,7 +319,7 @@ public: } else if(0x80 <= *p && *p <= 0x8f) { // FixMap if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user_, ((unsigned int)*p) & 0x0f, stack[top].obj()) < 0) { goto _failed; } + if(!template_callback_map(user_, ((unsigned int)*p) & 0x0f, stack[top].obj())) { goto _failed; } if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(((unsigned int)*p) & 0x0f); @@ -344,7 +344,7 @@ _fixed_trail_again: case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = _msgpack_load32(uint32_t,n); - if(template_callback_float(user_, mem.f, obj) < 0) { goto _failed; } + if(!template_callback_float(user_, mem.f, obj)) { goto _failed; } goto _push; } case CS_DOUBLE: { union { uint64_t i; double f; } mem; @@ -353,32 +353,32 @@ _fixed_trail_again: // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - if(template_callback_double(user_, mem.f, obj) < 0) { goto _failed; } + if(!template_callback_double(user_, mem.f, obj)) { goto _failed; } goto _push; } case CS_UINT_8: - if(template_callback_uint8(user_, *(uint8_t*)n, obj) < 0) { goto _failed; } + if(!template_callback_uint8(user_, *(uint8_t*)n, obj)) { goto _failed; } goto _push; case CS_UINT_16: - if(template_callback_uint16(user_, _msgpack_load16(uint16_t,n), obj) < 0) { goto _failed; } + if(!template_callback_uint16(user_, _msgpack_load16(uint16_t,n), obj)) { goto _failed; } goto _push; case CS_UINT_32: - if(template_callback_uint32(user_, _msgpack_load32(uint32_t,n), obj) < 0) { goto _failed; } + if(!template_callback_uint32(user_, _msgpack_load32(uint32_t,n), obj)) { goto _failed; } goto _push; case CS_UINT_64: - if(template_callback_uint64(user_, _msgpack_load64(uint64_t,n), obj) < 0) { goto _failed; } + if(!template_callback_uint64(user_, _msgpack_load64(uint64_t,n), obj)) { goto _failed; } goto _push; case CS_INT_8: - if(template_callback_int8(user_, *(int8_t*)n, obj) < 0) { goto _failed; } + if(!template_callback_int8(user_, *(int8_t*)n, obj)) { goto _failed; } goto _push; case CS_INT_16: - if(template_callback_int16(user_, _msgpack_load16(int16_t,n), obj) < 0) { goto _failed; } + if(!template_callback_int16(user_, _msgpack_load16(int16_t,n), obj)) { goto _failed; } goto _push; case CS_INT_32: - if(template_callback_int32(user_, _msgpack_load32(int32_t,n), obj) < 0) { goto _failed; } + if(!template_callback_int32(user_, _msgpack_load32(int32_t,n), obj)) { goto _failed; } goto _push; case CS_INT_64: - if(template_callback_int64(user_, _msgpack_load64(int64_t,n), obj) < 0) { goto _failed; } + if(!template_callback_int64(user_, _msgpack_load64(int64_t,n), obj)) { goto _failed; } goto _push; case CS_BIN_8: @@ -401,11 +401,11 @@ _fixed_trail_again: goto _fixed_trail_again; case ACS_RAW_VALUE: _raw_zero: - if(template_callback_raw(user_, (const char*)data, (const char*)n, trail, obj) < 0) { goto _failed; } + if(!template_callback_raw(user_, (const char*)data, (const char*)n, trail, obj)) { goto _failed; } goto _push; case CS_ARRAY_16: if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user_, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } + if(!template_callback_array(user_, _msgpack_load16(uint16_t, n), stack[top].obj())) { goto _failed; } if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(_msgpack_load16(uint16_t, n)); @@ -414,7 +414,7 @@ _raw_zero: case CS_ARRAY_32: /* FIXME security guard */ if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_array(user_, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } + if(!template_callback_array(user_, _msgpack_load32(uint32_t, n), stack[top].obj())) { goto _failed; } if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_ARRAY_ITEM); stack[top].set_count(_msgpack_load32(uint32_t, n)); @@ -423,7 +423,7 @@ _raw_zero: case CS_MAP_16: if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user_, _msgpack_load16(uint16_t, n), stack[top].obj()) < 0) { goto _failed; } + if(!template_callback_map(user_, _msgpack_load16(uint16_t, n), stack[top].obj())) { goto _failed; } if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(_msgpack_load16(uint16_t, n)); @@ -432,7 +432,7 @@ _raw_zero: case CS_MAP_32: /* FIXME security guard */ if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(template_callback_map(user_, _msgpack_load32(uint32_t, n), stack[top].obj()) < 0) { goto _failed; } + if(!template_callback_map(user_, _msgpack_load32(uint32_t, n), stack[top].obj())) { goto _failed; } if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } stack[top].set_ct(CT_MAP_KEY); stack[top].set_count(_msgpack_load32(uint32_t, n)); @@ -449,7 +449,7 @@ _push: c = &stack[top-1]; switch(c->ct()) { case CT_ARRAY_ITEM: - if(template_callback_array_item(user_, c->obj(), obj) < 0) { goto _failed; } + if(!template_callback_array_item(user_, c->obj(), obj)) { goto _failed; } if(c->decl_count() == 0) { obj = c->obj(); --top; @@ -462,7 +462,7 @@ _push: c->set_ct(CT_MAP_VALUE); goto _header_again; case CT_MAP_VALUE: - if(template_callback_map_item(user_, c->obj(), c->map_key(), obj) < 0) { goto _failed; } + if(!template_callback_map_item(user_, c->obj(), c->map_key(), obj)) { goto _failed; } if(c->decl_count() == 0) { obj = c->obj(); --top; From 63c26cd58b94abc3f4fccde7f78019ad96bd0146 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 15:08:09 +0900 Subject: [PATCH 034/153] Modified return type from bool to void in functions that always return true. --- src/msgpack/unpack.hpp | 106 ++++++++++++++++++++--------------------- 1 file changed, 52 insertions(+), 54 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 44eec64b..a842ba76 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -60,48 +60,48 @@ private: bool referenced_; }; -inline bool template_callback_uint8(unpack_user&, uint8_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } +inline void template_callback_uint8(unpack_user&, uint8_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline bool template_callback_uint16(unpack_user&, uint16_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } +inline void template_callback_uint16(unpack_user&, uint16_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline bool template_callback_uint32(unpack_user&, uint32_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } +inline void template_callback_uint32(unpack_user&, uint32_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline bool template_callback_uint64(unpack_user&, uint64_t d, object& o) -{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } +inline void template_callback_uint64(unpack_user&, uint64_t d, object& o) +{ o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline bool template_callback_int8(unpack_user&, int8_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } +inline void template_callback_int8(unpack_user&, int8_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline bool template_callback_int16(unpack_user&, int16_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } +inline void template_callback_int16(unpack_user&, int16_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline bool template_callback_int32(unpack_user&, int32_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } +inline void template_callback_int32(unpack_user&, int32_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline bool template_callback_int64(unpack_user&, int64_t d, object& o) -{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; return true; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; return true; } } +inline void template_callback_int64(unpack_user&, int64_t d, object& o) +{ if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline bool template_callback_float(unpack_user&, float d, object& o) -{ o.type = type::DOUBLE; o.via.dec = d; return true; } +inline void template_callback_float(unpack_user&, float d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; } -inline bool template_callback_double(unpack_user&, double d, object& o) -{ o.type = type::DOUBLE; o.via.dec = d; return true; } +inline void template_callback_double(unpack_user&, double d, object& o) +{ o.type = type::DOUBLE; o.via.dec = d; } -inline bool template_callback_nil(unpack_user&, object& o) -{ o.type = type::NIL; return true; } +inline void template_callback_nil(unpack_user&, object& o) +{ o.type = type::NIL; } -inline bool template_callback_true(unpack_user&, object& o) -{ o.type = type::BOOLEAN; o.via.boolean = true; return true; } +inline void template_callback_true(unpack_user&, object& o) +{ o.type = type::BOOLEAN; o.via.boolean = true; } -inline bool template_callback_false(unpack_user&, object& o) -{ o.type = type::BOOLEAN; o.via.boolean = false; return true; } +inline void template_callback_false(unpack_user&, object& o) +{ o.type = type::BOOLEAN; o.via.boolean = false; } inline bool template_callback_array(unpack_user&u, unsigned int n, object& o) { @@ -112,8 +112,8 @@ inline bool template_callback_array(unpack_user&u, unsigned int n, object& o) return true; } -inline bool template_callback_array_item(unpack_user&, object& c, object const& o) -{ c.via.array.ptr[c.via.array.size++] = o; return true; } +inline void template_callback_array_item(unpack_user&, object& c, object const& o) +{ c.via.array.ptr[c.via.array.size++] = o; } inline bool template_callback_map(unpack_user& u, unsigned int n, object& o) { @@ -124,21 +124,19 @@ inline bool template_callback_map(unpack_user& u, unsigned int n, object& o) return true; } -inline bool template_callback_map_item(unpack_user&, object& c, object const& k, object const& v) +inline void template_callback_map_item(unpack_user&, object& c, object const& k, object const& v) { c.via.map.ptr[c.via.map.size].key = k; c.via.map.ptr[c.via.map.size].val = v; ++c.via.map.size; - return true; } -inline bool template_callback_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) +inline void template_callback_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) { o.type = type::RAW; o.via.raw.ptr = p; o.via.raw.size = l; u.set_referenced(true); - return true; } @@ -240,23 +238,23 @@ public: case CS_HEADER: if (0) { } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum - if(!template_callback_uint8(user_, *(uint8_t*)p, obj)) { goto _failed; } + template_callback_uint8(user_, *(uint8_t*)p, obj); goto _push; } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum - if(!template_callback_int8(user_, *(int8_t*)p, obj)) { goto _failed; } + template_callback_int8(user_, *(int8_t*)p, obj); goto _push; } else if(0xc0 <= *p && *p <= 0xdf) { // Variable switch(*p) { case 0xc0: // nil - if(!template_callback_nil(user_, obj)) { goto _failed; } + template_callback_nil(user_, obj); goto _push; //case 0xc1: // string // again_terminal_trail(next_cs(p), p+1); case 0xc2: // false - if(!template_callback_false(user_, obj)) { goto _failed; } + template_callback_false(user_, obj); goto _push; case 0xc3: // true - if(!template_callback_true(user_, obj)) { goto _failed; } + template_callback_true(user_, obj); goto _push; case 0xc4: // bin 8 case 0xc5: // bin 16 @@ -344,7 +342,7 @@ _fixed_trail_again: case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = _msgpack_load32(uint32_t,n); - if(!template_callback_float(user_, mem.f, obj)) { goto _failed; } + template_callback_float(user_, mem.f, obj); goto _push; } case CS_DOUBLE: { union { uint64_t i; double f; } mem; @@ -353,32 +351,32 @@ _fixed_trail_again: // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - if(!template_callback_double(user_, mem.f, obj)) { goto _failed; } + template_callback_double(user_, mem.f, obj); goto _push; } case CS_UINT_8: - if(!template_callback_uint8(user_, *(uint8_t*)n, obj)) { goto _failed; } + template_callback_uint8(user_, *(uint8_t*)n, obj); goto _push; case CS_UINT_16: - if(!template_callback_uint16(user_, _msgpack_load16(uint16_t,n), obj)) { goto _failed; } + template_callback_uint16(user_, _msgpack_load16(uint16_t,n), obj); goto _push; case CS_UINT_32: - if(!template_callback_uint32(user_, _msgpack_load32(uint32_t,n), obj)) { goto _failed; } + template_callback_uint32(user_, _msgpack_load32(uint32_t,n), obj); goto _push; case CS_UINT_64: - if(!template_callback_uint64(user_, _msgpack_load64(uint64_t,n), obj)) { goto _failed; } + template_callback_uint64(user_, _msgpack_load64(uint64_t,n), obj); goto _push; case CS_INT_8: - if(!template_callback_int8(user_, *(int8_t*)n, obj)) { goto _failed; } + template_callback_int8(user_, *(int8_t*)n, obj); goto _push; case CS_INT_16: - if(!template_callback_int16(user_, _msgpack_load16(int16_t,n), obj)) { goto _failed; } + template_callback_int16(user_, _msgpack_load16(int16_t,n), obj); goto _push; case CS_INT_32: - if(!template_callback_int32(user_, _msgpack_load32(int32_t,n), obj)) { goto _failed; } + template_callback_int32(user_, _msgpack_load32(int32_t,n), obj); goto _push; case CS_INT_64: - if(!template_callback_int64(user_, _msgpack_load64(int64_t,n), obj)) { goto _failed; } + template_callback_int64(user_, _msgpack_load64(int64_t,n), obj); goto _push; case CS_BIN_8: @@ -401,7 +399,7 @@ _fixed_trail_again: goto _fixed_trail_again; case ACS_RAW_VALUE: _raw_zero: - if(!template_callback_raw(user_, (const char*)data, (const char*)n, trail, obj)) { goto _failed; } + template_callback_raw(user_, (const char*)data, (const char*)n, trail, obj); goto _push; case CS_ARRAY_16: if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ @@ -449,7 +447,7 @@ _push: c = &stack[top-1]; switch(c->ct()) { case CT_ARRAY_ITEM: - if(!template_callback_array_item(user_, c->obj(), obj)) { goto _failed; } + template_callback_array_item(user_, c->obj(), obj); if(c->decl_count() == 0) { obj = c->obj(); --top; @@ -462,7 +460,7 @@ _push: c->set_ct(CT_MAP_VALUE); goto _header_again; case CT_MAP_VALUE: - if(!template_callback_map_item(user_, c->obj(), c->map_key(), obj)) { goto _failed; } + template_callback_map_item(user_, c->obj(), c->map_key(), obj); if(c->decl_count() == 0) { obj = c->obj(); --top; From b7a1ba9ba0658a360ffee82fc1a666f31f3a8ff9 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 15:17:10 +0900 Subject: [PATCH 035/153] Modified the offset parameter of template_context::execute() from pointer to reference. --- src/msgpack/unpack.hpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index a842ba76..15c2f43d 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -213,11 +213,11 @@ public: return user_; } - int execute(const char* data, size_t len, size_t* off) + int execute(const char* data, size_t len, size_t& off) { - assert(len >= *off); + assert(len >= off); - const unsigned char* p = (unsigned char*)data + *off; + const unsigned char* p = (unsigned char*)data + off; const unsigned char* const pe = (unsigned char*)data + len; const void* n = nullptr; @@ -501,7 +501,7 @@ _end: cs_ = cs; trail_ = trail; top_ = top; - *off = p - (const unsigned char*)data; + off = p - (const unsigned char*)data; return ret; } @@ -850,7 +850,7 @@ inline bool unpacker::execute() inline int unpacker::execute_imp() { size_t off = off_; - int ret = ctx_.execute(buffer_, used_, &off_); + int ret = ctx_.execute(buffer_, used_, off_); if(off_ > off) { parsed_ += off_ - off; } @@ -958,7 +958,7 @@ unpack_imp(const char* data, size_t len, size_t* off, ctx.user().set_z(result_zone); ctx.user().set_referenced(false); - int e = ctx.execute(data, len, &noff); + int e = ctx.execute(data, len, noff); if(e < 0) { return UNPACK_PARSE_ERROR; } From 99971abc9b58cba66360e6a8d87fb4c626273afa Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 5 Sep 2013 15:57:31 +0900 Subject: [PATCH 036/153] Cleaned up template_context::execute(). --- src/msgpack/cpp_config.hpp | 10 + src/msgpack/unpack.hpp | 573 ++++++++++++++++++++++++------------- 2 files changed, 386 insertions(+), 197 deletions(-) diff --git a/src/msgpack/cpp_config.hpp b/src/msgpack/cpp_config.hpp index b80573a5..8db6d25b 100644 --- a/src/msgpack/cpp_config.hpp +++ b/src/msgpack/cpp_config.hpp @@ -45,6 +45,15 @@ T const& move(T const& t) return t; } +template +struct enable_if { + typedef T type; +}; + +template +struct enable_if { +}; + } // msgpack @@ -62,6 +71,7 @@ namespace msgpack { // utility using std::move; using std::swap; + using std::enable_if; } // msgpack diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 15c2f43d..26409813 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -27,6 +27,8 @@ #include + + #define COUNTER_SIZE (sizeof(_msgpack_atomic_counter_t)) #ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE @@ -183,6 +185,40 @@ inline _msgpack_atomic_counter_t get_count(void* buffer) return *(volatile _msgpack_atomic_counter_t*)buffer; } +template +inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { + return static_cast(*reinterpret_cast(n)); +} + +template +inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { + return static_cast( + (static_cast(reinterpret_cast(n)[0]) << 8) | + (static_cast(reinterpret_cast(n)[1]) )); +} + +template +inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { + return static_cast( + (static_cast(reinterpret_cast(n)[0]) << 24) | + (static_cast(reinterpret_cast(n)[1]) << 16) | + (static_cast(reinterpret_cast(n)[2]) << 8) | + (static_cast(reinterpret_cast(n)[3]) )); +} + +template +inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { + return static_cast( + (static_cast(reinterpret_cast(n)[0]) << 56) | + (static_cast(reinterpret_cast(n)[1]) << 48) | + (static_cast(reinterpret_cast(n)[2]) << 40) | + (static_cast(reinterpret_cast(n)[3]) << 32) | + (static_cast(reinterpret_cast(n)[4]) << 24) | + (static_cast(reinterpret_cast(n)[5]) << 16) | + (static_cast(reinterpret_cast(n)[6]) << 8) | + (static_cast(reinterpret_cast(n)[7]) )); +} + class template_context { public: template_context():cs_(CS_HEADER), trail_(0), top_(0) @@ -219,49 +255,60 @@ public: const unsigned char* p = (unsigned char*)data + off; const unsigned char* const pe = (unsigned char*)data + len; - const void* n = nullptr; + const char* n = nullptr; - unsigned int trail = trail_; + // to support register optimization unsigned int cs = cs_; + unsigned int trail = trail_; + unpack_user user = user_; unsigned int top = top_; template_unpack_stack* stack = stack_; object obj; template_unpack_stack* c = nullptr; - int ret; - - - if(p == pe) { goto _out; } + if(p == pe) { + off = update_attributes(p, data, top, cs, trail, user); + return 0; + } + bool fixed_trail_again = false; do { - switch(cs) { - case CS_HEADER: + if (cs == CS_HEADER) { + fixed_trail_again = false; if (0) { } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum - template_callback_uint8(user_, *(uint8_t*)p, obj); - goto _push; + template_callback_uint8(user, *(uint8_t*)p, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum - template_callback_int8(user_, *(int8_t*)p, obj); - goto _push; + template_callback_int8(user, *(int8_t*)p, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; } else if(0xc0 <= *p && *p <= 0xdf) { // Variable switch(*p) { - case 0xc0: // nil - template_callback_nil(user_, obj); - goto _push; + case 0xc0: { // nil + template_callback_nil(user, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; //case 0xc1: // string - // again_terminal_trail(next_cs(p), p+1); - case 0xc2: // false - template_callback_false(user_, obj); - goto _push; - case 0xc3: // true - template_callback_true(user_, obj); - goto _push; + case 0xc2: { // false + template_callback_false(user, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case 0xc3: { // true + template_callback_true(user, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; case 0xc4: // bin 8 case 0xc5: // bin 16 case 0xc6: // bin 32 trail = 1 << (((unsigned int)*p) & 0x03); cs = next_cs(p); - goto _fixed_trail_again; + fixed_trail_again = true; + break; //case 0xc7: //case 0xc8: @@ -278,7 +325,8 @@ public: case 0xd3: // signed int 64 trail = 1 << (((unsigned int)*p) & 0x03); cs = next_cs(p); - goto _fixed_trail_again; + fixed_trail_again = true; + break; //case 0xd4: //case 0xd5: //case 0xd6: // big integer 16 @@ -289,234 +337,365 @@ public: case 0xdb: // raw 32 (str 32) trail = 1 << ((((unsigned int)*p) & 0x03) - 1); cs = next_cs(p); - goto _fixed_trail_again; + fixed_trail_again = true; + break; case 0xdc: // array 16 case 0xdd: // array 32 case 0xde: // map 16 case 0xdf: // map 32 trail = 2 << (((unsigned int)*p) & 0x01); cs = next_cs(p); - goto _fixed_trail_again; + fixed_trail_again = true; + break; default: - goto _failed; + off = update_attributes(p, data, top, cs, trail, user); + return -1; } } else if(0xa0 <= *p && *p <= 0xbf) { // FixRaw trail = (unsigned int)*p & 0x1f; - if(trail == 0) { goto _raw_zero; } + if(trail == 0) { + template_callback_raw(user, data, n, trail, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } cs = ACS_RAW_VALUE; - goto _fixed_trail_again; + fixed_trail_again = true; } else if(0x90 <= *p && *p <= 0x9f) { // FixArray - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(!template_callback_array(user_, ((unsigned int)*p) & 0x0f, stack[top].obj())) { goto _failed; } - if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } - stack[top].set_ct(CT_ARRAY_ITEM); - stack[top].set_count(((unsigned int)*p) & 0x0f); - ++top; - goto _header_again; - + if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && template_callback_array(user, ((unsigned int)*p) & 0x0f, stack[top].obj())) { + if((((unsigned int)*p) & 0x0f) == 0) { + obj = stack[top].obj(); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + stack[top].set_ct(CT_ARRAY_ITEM); + stack[top].set_count(((unsigned int)*p) & 0x0f); + ++top; + header_again(cs, p); + } + } + else { + off = update_attributes(p, data, top, cs, trail, user); + return -1; + } } else if(0x80 <= *p && *p <= 0x8f) { // FixMap - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(!template_callback_map(user_, ((unsigned int)*p) & 0x0f, stack[top].obj())) { goto _failed; } - if((((unsigned int)*p) & 0x0f) == 0) { obj = stack[top].obj(); goto _push; } - stack[top].set_ct(CT_MAP_KEY); - stack[top].set_count(((unsigned int)*p) & 0x0f); - ++top; - goto _header_again; - + if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && template_callback_map(user, ((unsigned int)*p) & 0x0f, stack[top].obj())) { + if((((unsigned int)*p) & 0x0f) == 0) { + obj = stack[top].obj(); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + stack[top].set_ct(CT_MAP_KEY); + stack[top].set_count(((unsigned int)*p) & 0x0f); + ++top; + header_again(cs, p); + } + } + else { + off = update_attributes(p, data, top, cs, trail, user); + return -1; + } } else { - goto _failed; + off = update_attributes(p, data, top, cs, trail, user); + return -1; } // end CS_HEADER - - -_fixed_trail_again: - ++p; - - default: - if((size_t)(pe - p) < trail) { goto _out; } - n = p; p += trail - 1; + } + if (cs != CS_HEADER || fixed_trail_again) { + if (fixed_trail_again) { + ++p; + fixed_trail_again = false; + } + if((size_t)(pe - p) < trail) { + off = update_attributes(p, data, top, cs, trail, user); + return 0; + } + n = reinterpret_cast(p); p += trail - 1; switch(cs) { //case CS_ //case CS_ case CS_FLOAT: { union { uint32_t i; float f; } mem; - mem.i = _msgpack_load32(uint32_t,n); - template_callback_float(user_, mem.f, obj); - goto _push; } + mem.i = load(n); + template_callback_float(user, mem.f, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; case CS_DOUBLE: { union { uint64_t i; double f; } mem; - mem.i = _msgpack_load64(uint64_t,n); + mem.i = load(n); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - template_callback_double(user_, mem.f, obj); - goto _push; } - case CS_UINT_8: - template_callback_uint8(user_, *(uint8_t*)n, obj); - goto _push; - case CS_UINT_16: - template_callback_uint16(user_, _msgpack_load16(uint16_t,n), obj); - goto _push; - case CS_UINT_32: - template_callback_uint32(user_, _msgpack_load32(uint32_t,n), obj); - goto _push; - case CS_UINT_64: - template_callback_uint64(user_, _msgpack_load64(uint64_t,n), obj); - goto _push; - - case CS_INT_8: - template_callback_int8(user_, *(int8_t*)n, obj); - goto _push; - case CS_INT_16: - template_callback_int16(user_, _msgpack_load16(int16_t,n), obj); - goto _push; - case CS_INT_32: - template_callback_int32(user_, _msgpack_load32(int32_t,n), obj); - goto _push; - case CS_INT_64: - template_callback_int64(user_, _msgpack_load64(int64_t,n), obj); - goto _push; - + template_callback_double(user, mem.f, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_UINT_8: { + template_callback_uint8(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_UINT_16: { + template_callback_uint16(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_UINT_32: { + template_callback_uint32(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_UINT_64: { + template_callback_uint64(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_INT_8: { + template_callback_int8(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_INT_16: { + template_callback_int16(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_INT_32: { + template_callback_int32(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_INT_64: { + template_callback_int64(user, load(n), obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; case CS_BIN_8: case CS_RAW_8: - trail = *(uint8_t*)n; - if(trail == 0) { goto _raw_zero; } - cs = ACS_RAW_VALUE; - goto _fixed_trail_again; + trail = load(n); + if(trail == 0) { + template_callback_raw(user, data, n, trail, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + cs = ACS_RAW_VALUE; + fixed_trail_again = true; + } + break; case CS_BIN_16: case CS_RAW_16: - trail = _msgpack_load16(uint16_t, n); - if(trail == 0) { goto _raw_zero; } - cs = ACS_RAW_VALUE; - goto _fixed_trail_again; + trail = load( n); + if(trail == 0) { + template_callback_raw(user, data, n, trail, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + cs = ACS_RAW_VALUE; + fixed_trail_again = true; + } + break; case CS_BIN_32: case CS_RAW_32: - trail = _msgpack_load32(uint32_t, n); - if(trail == 0) { goto _raw_zero; } - cs = ACS_RAW_VALUE; - goto _fixed_trail_again; - case ACS_RAW_VALUE: -_raw_zero: - template_callback_raw(user_, (const char*)data, (const char*)n, trail, obj); - goto _push; + trail = load( n); + if(trail == 0) { + template_callback_raw(user, data, n, trail, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + cs = ACS_RAW_VALUE; + fixed_trail_again = true; + } + break; + case ACS_RAW_VALUE: { + template_callback_raw(user, data, n, trail, obj); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; case CS_ARRAY_16: - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(!template_callback_array(user_, _msgpack_load16(uint16_t, n), stack[top].obj())) { goto _failed; } - if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } - stack[top].set_ct(CT_ARRAY_ITEM); - stack[top].set_count(_msgpack_load16(uint16_t, n)); - ++top; - goto _header_again; + if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && template_callback_array(user, load(n), stack[top].obj())) { + if(load(n) == 0) { + obj = stack[top].obj(); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + stack[top].set_ct(CT_ARRAY_ITEM); + stack[top].set_count(load(n)); + ++top; + header_again(cs, p); + } + } + else { + off = update_attributes(p, data, top, cs, trail, user); + return -1; + } + break; case CS_ARRAY_32: /* FIXME security guard */ - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(!template_callback_array(user_, _msgpack_load32(uint32_t, n), stack[top].obj())) { goto _failed; } - if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } - stack[top].set_ct(CT_ARRAY_ITEM); - stack[top].set_count(_msgpack_load32(uint32_t, n)); - ++top; - goto _header_again; - + if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && template_callback_array(user, load(n), stack[top].obj())) { + if(load(n) == 0) { + obj = stack[top].obj(); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + stack[top].set_ct(CT_ARRAY_ITEM); + stack[top].set_count(load(n)); + ++top; + header_again(cs, p); + } + } + else { + off = update_attributes(p, data, top, cs, trail, user); + return -1; + } + break; case CS_MAP_16: - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(!template_callback_map(user_, _msgpack_load16(uint16_t, n), stack[top].obj())) { goto _failed; } - if(_msgpack_load16(uint16_t, n) == 0) { obj = stack[top].obj(); goto _push; } - stack[top].set_ct(CT_MAP_KEY); - stack[top].set_count(_msgpack_load16(uint16_t, n)); - ++top; - goto _header_again; + if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && template_callback_map(user, load(n), stack[top].obj())) { + if(load(n) == 0) { + obj = stack[top].obj(); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + stack[top].set_ct(CT_MAP_KEY); + stack[top].set_count(load(n)); + ++top; + header_again(cs, p); + } + } + else { + off = update_attributes(p, data, top, cs, trail, user); + return -1; + } + break; case CS_MAP_32: /* FIXME security guard */ - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ - if(!template_callback_map(user_, _msgpack_load32(uint32_t, n), stack[top].obj())) { goto _failed; } - if(_msgpack_load32(uint32_t, n) == 0) { obj = stack[top].obj(); goto _push; } - stack[top].set_ct(CT_MAP_KEY); - stack[top].set_count(_msgpack_load32(uint32_t, n)); - ++top; - goto _header_again; - + if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && template_callback_map(user, load(n), stack[top].obj())) { + if(load(n) == 0) { + obj = stack[top].obj(); + int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + stack[top].set_ct(CT_MAP_KEY); + stack[top].set_count(load(n)); + ++top; + header_again(cs, p); + } + } + else { + off = update_attributes(p, data, top, cs, trail, user); + return -1; + } + break; default: - goto _failed; + off = update_attributes(p, data, top, cs, trail, user); + return -1; } } - -_push: - if(top == 0) { goto _finish; } - c = &stack[top-1]; - switch(c->ct()) { - case CT_ARRAY_ITEM: - template_callback_array_item(user_, c->obj(), obj); - if(c->decl_count() == 0) { - obj = c->obj(); - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - goto _header_again; - case CT_MAP_KEY: - c->set_map_key(obj); - c->set_ct(CT_MAP_VALUE); - goto _header_again; - case CT_MAP_VALUE: - template_callback_map_item(user_, c->obj(), c->map_key(), obj); - if(c->decl_count() == 0) { - obj = c->obj(); - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - c->set_ct(CT_MAP_KEY); - goto _header_again; - - default: - goto _failed; - } - -_header_again: - cs = CS_HEADER; - ++p; } while(p != pe); - goto _out; - -_finish: - stack[0].setObj(obj); - ++p; - ret = 1; - /*printf("-- finish --\n"); */ - goto _end; - -_failed: - /*printf("** FAILED **\n"); */ - ret = -1; - goto _end; - -_out: - ret = 0; - goto _end; - -_end: - cs_ = cs; - trail_ = trail; - top_ = top; - off = p - (const unsigned char*)data; - - return ret; + off = update_attributes(p, data, top, cs, trail, user); + return 0; } private: template - static unsigned int next_cs(T p) + static inline unsigned int next_cs(T p) { return (unsigned int)*p & 0x1f; } + size_t update_attributes(const unsigned char* current, const char* origin, unsigned int top, unsigned int cs, unsigned int trail, unpack_user const& user) { + trail_ = trail; + top_ = top; + cs_ = cs; + user_ = user; + return reinterpret_cast(current) - origin; + } + + static void header_again(unsigned int& cs, const unsigned char*& current) { + cs = CS_HEADER; + ++current; + } + static int push_item(template_unpack_stack* stack, template_unpack_stack*& c, object& obj, unsigned int top, unpack_user& user) { + bool finish = false; + while (!finish) { + if(top == 0) { + return 1; + } + c = &stack[top-1]; + switch(c->ct()) { + case CT_ARRAY_ITEM: + template_callback_array_item(user, c->obj(), obj); + if(c->decl_count() == 0) { + obj = c->obj(); + --top; + /*printf("stack pop %d\n", top);*/ + } + else { + finish = true; + } + break; + case CT_MAP_KEY: + c->set_map_key(obj); + c->set_ct(CT_MAP_VALUE); + finish = true; + break; + case CT_MAP_VALUE: + template_callback_map_item(user, c->obj(), c->map_key(), obj); + if(c->decl_count() == 0) { + obj = c->obj(); + --top; + /*printf("stack pop %d\n", top);*/ + } + else { + c->set_ct(CT_MAP_KEY); + finish = true; + } + break; + default: + return -1; + } + } + return 0; + } + + int push_proc(template_unpack_stack* stack, template_unpack_stack*& c, object& obj, const unsigned char*& current, const char* origin, size_t& off, unsigned int top, unsigned int& cs, unsigned int trail, unpack_user& user) { + int ret = push_item(stack, c, obj, top, user); + if (ret > 0) { + stack[0].setObj(obj); + ++current; + /*printf("-- finish --\n"); */ + off = update_attributes(current, origin, top, cs, trail, user); + } + else if (ret < 0) { + off = update_attributes(current, origin, top, cs, trail, user); + } + else { + header_again(cs, current); + } + return ret; + } + private: + unsigned int trail_; unpack_user user_; unsigned int cs_; - unsigned int trail_; unsigned int top_; template_unpack_stack stack_[MSGPACK_EMBED_STACK_SIZE]; }; @@ -647,7 +826,7 @@ public: private: void expand_buffer(size_t size); - int execute_imp(); + int execute_imp(); bool flush_zone(); private: From 7675c15fa942281f6f6635eca7b308bd9572213e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 6 Sep 2013 18:43:40 +0900 Subject: [PATCH 037/153] Added a comment. --- src/msgpack/sysdep.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/msgpack/sysdep.h b/src/msgpack/sysdep.h index f4776718..7756bf59 100644 --- a/src/msgpack/sysdep.h +++ b/src/msgpack/sysdep.h @@ -152,7 +152,7 @@ typedef unsigned int _msgpack_atomic_counter_t; (((uint64_t)((uint8_t*)(from))[6]) << 8) | \ (((uint64_t)((uint8_t*)(from))[7]) ) )) -#else +#else /* __LITTLE_ENDIAN__ */ #define _msgpack_be16(x) (x) #define _msgpack_be32(x) (x) From 561b6b583d7321763b677747f999436399e4a42e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 9 Sep 2013 12:30:32 +0900 Subject: [PATCH 038/153] Modified data members initialize sequence to fix a warning. --- src/msgpack/unpack.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 26409813..dcc6a55c 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -221,7 +221,7 @@ inline T load(const char* n, typename msgpack::enable_if::type* class template_context { public: - template_context():cs_(CS_HEADER), trail_(0), top_(0) + template_context():trail_(0), cs_(CS_HEADER), top_(0) { stack_[0].setObj(object()); } From 7fba3484c5b8d1f726d7484a267e376d125504aa Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 9 Sep 2013 12:30:32 +0900 Subject: [PATCH 039/153] Renamed template callback functions. Moved aggregate unpacking and pushing procedure to the function push_aggregate. --- src/msgpack/unpack.hpp | 356 +++++++++++++++++++---------------------- 1 file changed, 168 insertions(+), 188 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index dcc6a55c..37c50c81 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -62,78 +62,80 @@ private: bool referenced_; }; -inline void template_callback_uint8(unpack_user&, uint8_t d, object& o) +inline void unpack_uint8(unpack_user&, uint8_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void template_callback_uint16(unpack_user&, uint16_t d, object& o) +inline void unpack_uint16(unpack_user&, uint16_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void template_callback_uint32(unpack_user&, uint32_t d, object& o) +inline void unpack_uint32(unpack_user&, uint32_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void template_callback_uint64(unpack_user&, uint64_t d, object& o) +inline void unpack_uint64(unpack_user&, uint64_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void template_callback_int8(unpack_user&, int8_t d, object& o) +inline void unpack_int8(unpack_user&, int8_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void template_callback_int16(unpack_user&, int16_t d, object& o) +inline void unpack_int16(unpack_user&, int16_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void template_callback_int32(unpack_user&, int32_t d, object& o) +inline void unpack_int32(unpack_user&, int32_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void template_callback_int64(unpack_user&, int64_t d, object& o) +inline void unpack_int64(unpack_user&, int64_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void template_callback_float(unpack_user&, float d, object& o) +inline void unpack_float(unpack_user&, float d, object& o) { o.type = type::DOUBLE; o.via.dec = d; } -inline void template_callback_double(unpack_user&, double d, object& o) +inline void unpack_double(unpack_user&, double d, object& o) { o.type = type::DOUBLE; o.via.dec = d; } -inline void template_callback_nil(unpack_user&, object& o) +inline void unpack_nil(unpack_user&, object& o) { o.type = type::NIL; } -inline void template_callback_true(unpack_user&, object& o) +inline void unpack_true(unpack_user&, object& o) { o.type = type::BOOLEAN; o.via.boolean = true; } -inline void template_callback_false(unpack_user&, object& o) +inline void unpack_false(unpack_user&, object& o) { o.type = type::BOOLEAN; o.via.boolean = false; } -inline bool template_callback_array(unpack_user&u, unsigned int n, object& o) -{ - o.type = type::ARRAY; - o.via.array.size = 0; - o.via.array.ptr = (object*)u.z().malloc(n*sizeof(object)); - if(o.via.array.ptr == NULL) { return false; } - return true; -} +struct unpack_array { + bool operator()(unpack_user&u, unsigned int n, object& o) const { + o.type = type::ARRAY; + o.via.array.size = 0; + o.via.array.ptr = (object*)u.z().malloc(n*sizeof(object)); + if(o.via.array.ptr == NULL) { return false; } + return true; + } +}; -inline void template_callback_array_item(unpack_user&, object& c, object const& o) +inline void unpack_array_item(unpack_user&, object& c, object const& o) { c.via.array.ptr[c.via.array.size++] = o; } -inline bool template_callback_map(unpack_user& u, unsigned int n, object& o) -{ - o.type = type::MAP; - o.via.map.size = 0; - o.via.map.ptr = (object_kv*)u.z().malloc(n*sizeof(object_kv)); - if(o.via.map.ptr == NULL) { return false; } - return true; -} +struct unpack_map { + bool operator()(unpack_user& u, unsigned int n, object& o) const { + o.type = type::MAP; + o.via.map.size = 0; + o.via.map.ptr = (object_kv*)u.z().malloc(n*sizeof(object_kv)); + if(o.via.map.ptr == NULL) { return false; } + return true; + } +}; -inline void template_callback_map_item(unpack_user&, object& c, object const& k, object const& v) +inline void unpack_map_item(unpack_user&, object& c, object const& k, object const& v) { c.via.map.ptr[c.via.map.size].key = k; c.via.map.ptr[c.via.map.size].val = v; ++c.via.map.size; } -inline void template_callback_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) +inline void unpack_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) { o.type = type::RAW; o.via.raw.ptr = p; @@ -185,6 +187,15 @@ inline _msgpack_atomic_counter_t get_count(void* buffer) return *(volatile _msgpack_atomic_counter_t*)buffer; } +struct fix_tag { + char f1[65]; // FIXME unique size is required. or use is_same meta function. +}; + +template +inline unsigned int load(const char* n, typename msgpack::enable_if::type* = nullptr) { + return static_cast(*reinterpret_cast(n)) & 0x0f; +} + template inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { return static_cast(*reinterpret_cast(n)); @@ -253,8 +264,8 @@ public: { assert(len >= off); - const unsigned char* p = (unsigned char*)data + off; - const unsigned char* const pe = (unsigned char*)data + len; + const char* p = data + off; + const char* const pe = data + len; const char* n = nullptr; // to support register optimization @@ -275,30 +286,31 @@ public: do { if (cs == CS_HEADER) { fixed_trail_again = false; + int selector = *reinterpret_cast(p); if (0) { - } else if(0x00 <= *p && *p <= 0x7f) { // Positive Fixnum - template_callback_uint8(user, *(uint8_t*)p, obj); + } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum + unpack_uint8(user, *(uint8_t*)p, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; - } else if(0xe0 <= *p && *p <= 0xff) { // Negative Fixnum - template_callback_int8(user, *(int8_t*)p, obj); + } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum + unpack_int8(user, *(int8_t*)p, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; - } else if(0xc0 <= *p && *p <= 0xdf) { // Variable - switch(*p) { + } else if(0xc0 <= selector && selector <= 0xdf) { // Variable + switch(selector) { case 0xc0: { // nil - template_callback_nil(user, obj); + unpack_nil(user, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; //case 0xc1: // string case 0xc2: { // false - template_callback_false(user, obj); + unpack_false(user, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case 0xc3: { // true - template_callback_true(user, obj); + unpack_true(user, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; @@ -351,54 +363,24 @@ public: off = update_attributes(p, data, top, cs, trail, user); return -1; } - } else if(0xa0 <= *p && *p <= 0xbf) { // FixRaw + } else if(0xa0 <= selector && selector <= 0xbf) { // FixRaw trail = (unsigned int)*p & 0x1f; if(trail == 0) { - template_callback_raw(user, data, n, trail, obj); + unpack_raw(user, data, n, trail, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } cs = ACS_RAW_VALUE; fixed_trail_again = true; - } else if(0x90 <= *p && *p <= 0x9f) { // FixArray - if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && template_callback_array(user, ((unsigned int)*p) & 0x0f, stack[top].obj())) { - if((((unsigned int)*p) & 0x0f) == 0) { - obj = stack[top].obj(); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); - if (ret != 0) return ret; - } - else { - stack[top].set_ct(CT_ARRAY_ITEM); - stack[top].set_count(((unsigned int)*p) & 0x0f); - ++top; - header_again(cs, p); - } - } - else { - off = update_attributes(p, data, top, cs, trail, user); - return -1; - } - } else if(0x80 <= *p && *p <= 0x8f) { // FixMap - if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && template_callback_map(user, ((unsigned int)*p) & 0x0f, stack[top].obj())) { - if((((unsigned int)*p) & 0x0f) == 0) { - obj = stack[top].obj(); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); - if (ret != 0) return ret; - } - else { - stack[top].set_ct(CT_MAP_KEY); - stack[top].set_count(((unsigned int)*p) & 0x0f); - ++top; - header_again(cs, p); - } - } - else { - off = update_attributes(p, data, top, cs, trail, user); - return -1; - } + } else if(0x90 <= selector && selector <= 0x9f) { // FixArray + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, stack, c, obj, p, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } else if(0x80 <= selector && selector <= 0x8f) { // FixMap + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, stack, c, obj, p, p, data, off, top, cs, trail, user); + if (ret != 0) return ret; } else { off = update_attributes(p, data, top, cs, trail, user); return -1; @@ -414,14 +396,15 @@ public: off = update_attributes(p, data, top, cs, trail, user); return 0; } - n = reinterpret_cast(p); p += trail - 1; + n = p; + p += trail - 1; switch(cs) { //case CS_ //case CS_ case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = load(n); - template_callback_float(user, mem.f, obj); + unpack_float(user, mem.f, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; @@ -432,47 +415,47 @@ public: // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - template_callback_double(user, mem.f, obj); + unpack_double(user, mem.f, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_UINT_8: { - template_callback_uint8(user, load(n), obj); + unpack_uint8(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_UINT_16: { - template_callback_uint16(user, load(n), obj); + unpack_uint16(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_UINT_32: { - template_callback_uint32(user, load(n), obj); + unpack_uint32(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_UINT_64: { - template_callback_uint64(user, load(n), obj); + unpack_uint64(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_INT_8: { - template_callback_int8(user, load(n), obj); + unpack_int8(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_INT_16: { - template_callback_int16(user, load(n), obj); + unpack_int16(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_INT_32: { - template_callback_int32(user, load(n), obj); + unpack_int32(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; case CS_INT_64: { - template_callback_int64(user, load(n), obj); + unpack_int64(user, load(n), obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; @@ -480,7 +463,7 @@ public: case CS_RAW_8: trail = load(n); if(trail == 0) { - template_callback_raw(user, data, n, trail, obj); + unpack_raw(user, data, n, trail, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } @@ -491,9 +474,9 @@ public: break; case CS_BIN_16: case CS_RAW_16: - trail = load( n); + trail = load(n); if(trail == 0) { - template_callback_raw(user, data, n, trail, obj); + unpack_raw(user, data, n, trail, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } @@ -504,9 +487,9 @@ public: break; case CS_BIN_32: case CS_RAW_32: - trail = load( n); + trail = load(n); if(trail == 0) { - template_callback_raw(user, data, n, trail, obj); + unpack_raw(user, data, n, trail, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } @@ -516,92 +499,32 @@ public: } break; case ACS_RAW_VALUE: { - template_callback_raw(user, data, n, trail, obj); + unpack_raw(user, data, n, trail, obj); int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); if (ret != 0) return ret; } break; - case CS_ARRAY_16: - if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && template_callback_array(user, load(n), stack[top].obj())) { - if(load(n) == 0) { - obj = stack[top].obj(); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); - if (ret != 0) return ret; - } - else { - stack[top].set_ct(CT_ARRAY_ITEM); - stack[top].set_count(load(n)); - ++top; - header_again(cs, p); - } - } - else { - off = update_attributes(p, data, top, cs, trail, user); - return -1; - } - break; - case CS_ARRAY_32: + case CS_ARRAY_16: { + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, stack, c, obj, p, n, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_ARRAY_32: { /* FIXME security guard */ - if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && template_callback_array(user, load(n), stack[top].obj())) { - if(load(n) == 0) { - obj = stack[top].obj(); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); - if (ret != 0) return ret; - } - else { - stack[top].set_ct(CT_ARRAY_ITEM); - stack[top].set_count(load(n)); - ++top; - header_again(cs, p); - } - } - else { - off = update_attributes(p, data, top, cs, trail, user); - return -1; - } - break; - case CS_MAP_16: - if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && template_callback_map(user, load(n), stack[top].obj())) { - if(load(n) == 0) { - obj = stack[top].obj(); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); - if (ret != 0) return ret; - } - else { - stack[top].set_ct(CT_MAP_KEY); - stack[top].set_count(load(n)); - ++top; - header_again(cs, p); - } - } - else { - off = update_attributes(p, data, top, cs, trail, user); - return -1; - } - break; - case CS_MAP_32: + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, stack, c, obj, p, n, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_MAP_16: { + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, stack, c, obj, p, n, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; + case CS_MAP_32: { /* FIXME security guard */ - if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && template_callback_map(user, load(n), stack[top].obj())) { - if(load(n) == 0) { - obj = stack[top].obj(); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); - if (ret != 0) return ret; - } - else { - stack[top].set_ct(CT_MAP_KEY); - stack[top].set_count(load(n)); - ++top; - header_again(cs, p); - } - } - else { - off = update_attributes(p, data, top, cs, trail, user); - return -1; - } - break; + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, stack, c, obj, p, n, data, off, top, cs, trail, user); + if (ret != 0) return ret; + } break; default: off = update_attributes(p, data, top, cs, trail, user); return -1; @@ -615,24 +538,71 @@ public: private: template - static inline unsigned int next_cs(T p) + static unsigned int next_cs(T p) { return (unsigned int)*p & 0x1f; } - size_t update_attributes(const unsigned char* current, const char* origin, unsigned int top, unsigned int cs, unsigned int trail, unpack_user const& user) { + template + int push_aggregate( + Func const& f, + unsigned int ct, + template_unpack_stack* stack, + template_unpack_stack*& c, + object& obj, + const char*& current, + const char* load_pos, + const char* origin, + size_t& off, + unsigned int& top, + unsigned int& cs, + unsigned int trail, + unpack_user& user) { + if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && f(user, load(load_pos), stack[top].obj())) { + if(load(load_pos) == 0) { + obj = stack[top].obj(); + int ret = push_proc(stack, c, obj, current, origin, off, top, cs, trail, user); + if (ret != 0) return ret; + } + else { + stack[top].set_ct(ct); + stack[top].set_count(load(load_pos)); + ++top; + header_again(cs, current); + } + } + else { + off = update_attributes(current, origin, top, cs, trail, user); + return -1; + } + return 0; + } + + size_t update_attributes( + const char* current, + const char* origin, + unsigned int top, + unsigned int cs, + unsigned int trail, + unpack_user const& user) { trail_ = trail; top_ = top; cs_ = cs; user_ = user; - return reinterpret_cast(current) - origin; + return current - origin; } - static void header_again(unsigned int& cs, const unsigned char*& current) { + static void header_again(unsigned int& cs, const char*& current) { cs = CS_HEADER; ++current; } - static int push_item(template_unpack_stack* stack, template_unpack_stack*& c, object& obj, unsigned int top, unpack_user& user) { + static int push_item( + template_unpack_stack* stack, + template_unpack_stack*& c, + object& obj, + unsigned int top, + unpack_user& user) { bool finish = false; while (!finish) { if(top == 0) { @@ -641,7 +611,7 @@ private: c = &stack[top-1]; switch(c->ct()) { case CT_ARRAY_ITEM: - template_callback_array_item(user, c->obj(), obj); + unpack_array_item(user, c->obj(), obj); if(c->decl_count() == 0) { obj = c->obj(); --top; @@ -657,7 +627,7 @@ private: finish = true; break; case CT_MAP_VALUE: - template_callback_map_item(user, c->obj(), c->map_key(), obj); + unpack_map_item(user, c->obj(), c->map_key(), obj); if(c->decl_count() == 0) { obj = c->obj(); --top; @@ -675,7 +645,17 @@ private: return 0; } - int push_proc(template_unpack_stack* stack, template_unpack_stack*& c, object& obj, const unsigned char*& current, const char* origin, size_t& off, unsigned int top, unsigned int& cs, unsigned int trail, unpack_user& user) { + int push_proc( + template_unpack_stack* stack, + template_unpack_stack*& c, + object& obj, + const char*& current, + const char* origin, + size_t& off, + unsigned int top, + unsigned int& cs, + unsigned int trail, + unpack_user& user) { int ret = push_item(stack, c, obj, top, user); if (ret > 0) { stack[0].setObj(obj); From f7692691cae436f4a5d838312eae2fa29011efa1 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 11 Sep 2013 11:12:32 +0900 Subject: [PATCH 040/153] Removed local variables top, cs, and user and access directly member variables top_, cs_, and user_. The local variable trail is preserved to suppourt register optimization. Other variables don't contribute increasing speed even though they are on registers. --- src/msgpack/unpack.hpp | 205 ++++++++++++++++++----------------------- 1 file changed, 91 insertions(+), 114 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 37c50c81..107b2a15 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -269,56 +269,52 @@ public: const char* n = nullptr; // to support register optimization - unsigned int cs = cs_; unsigned int trail = trail_; - unpack_user user = user_; - unsigned int top = top_; - template_unpack_stack* stack = stack_; object obj; template_unpack_stack* c = nullptr; if(p == pe) { - off = update_attributes(p, data, top, cs, trail, user); + off = update_attributes(p, data, trail); return 0; } bool fixed_trail_again = false; do { - if (cs == CS_HEADER) { + if (cs_ == CS_HEADER) { fixed_trail_again = false; int selector = *reinterpret_cast(p); if (0) { } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum - unpack_uint8(user, *(uint8_t*)p, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_uint8(user_, *(uint8_t*)p, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum - unpack_int8(user, *(int8_t*)p, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_int8(user_, *(int8_t*)p, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else if(0xc0 <= selector && selector <= 0xdf) { // Variable switch(selector) { case 0xc0: { // nil - unpack_nil(user, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_nil(user_, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; //case 0xc1: // string case 0xc2: { // false - unpack_false(user, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_false(user_, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case 0xc3: { // true - unpack_true(user, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_true(user_, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case 0xc4: // bin 8 case 0xc5: // bin 16 case 0xc6: // bin 32 trail = 1 << (((unsigned int)*p) & 0x03); - cs = next_cs(p); + cs_ = next_cs(p); fixed_trail_again = true; break; @@ -336,7 +332,7 @@ public: case 0xd2: // signed int 32 case 0xd3: // signed int 64 trail = 1 << (((unsigned int)*p) & 0x03); - cs = next_cs(p); + cs_ = next_cs(p); fixed_trail_again = true; break; //case 0xd4: @@ -348,7 +344,7 @@ public: case 0xda: // raw 16 (str 16) case 0xdb: // raw 32 (str 32) trail = 1 << ((((unsigned int)*p) & 0x03) - 1); - cs = next_cs(p); + cs_ = next_cs(p); fixed_trail_again = true; break; case 0xdc: // array 16 @@ -356,56 +352,56 @@ public: case 0xde: // map 16 case 0xdf: // map 32 trail = 2 << (((unsigned int)*p) & 0x01); - cs = next_cs(p); + cs_ = next_cs(p); fixed_trail_again = true; break; default: - off = update_attributes(p, data, top, cs, trail, user); + off = update_attributes(p, data, trail); return -1; } } else if(0xa0 <= selector && selector <= 0xbf) { // FixRaw trail = (unsigned int)*p & 0x1f; if(trail == 0) { - unpack_raw(user, data, n, trail, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_raw(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } - cs = ACS_RAW_VALUE; + cs_ = ACS_RAW_VALUE; fixed_trail_again = true; } else if(0x90 <= selector && selector <= 0x9f) { // FixArray int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, stack, c, obj, p, p, data, off, top, cs, trail, user); + unpack_array(), CT_ARRAY_ITEM, c, obj, p, p, data, off, trail); if (ret != 0) return ret; } else if(0x80 <= selector && selector <= 0x8f) { // FixMap int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, stack, c, obj, p, p, data, off, top, cs, trail, user); + unpack_map(), CT_MAP_KEY, c, obj, p, p, data, off, trail); if (ret != 0) return ret; } else { - off = update_attributes(p, data, top, cs, trail, user); + off = update_attributes(p, data, trail); return -1; } // end CS_HEADER } - if (cs != CS_HEADER || fixed_trail_again) { + if (cs_ != CS_HEADER || fixed_trail_again) { if (fixed_trail_again) { ++p; fixed_trail_again = false; } if((size_t)(pe - p) < trail) { - off = update_attributes(p, data, top, cs, trail, user); + off = update_attributes(p, data, trail); return 0; } n = p; p += trail - 1; - switch(cs) { + switch(cs_) { //case CS_ //case CS_ case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = load(n); - unpack_float(user, mem.f, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_float(user_, mem.f, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_DOUBLE: { @@ -415,60 +411,60 @@ public: // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - unpack_double(user, mem.f, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_double(user_, mem.f, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_UINT_8: { - unpack_uint8(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_uint8(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_UINT_16: { - unpack_uint16(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_uint16(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_UINT_32: { - unpack_uint32(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_uint32(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_UINT_64: { - unpack_uint64(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_uint64(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_INT_8: { - unpack_int8(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_int8(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_INT_16: { - unpack_int16(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_int16(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_INT_32: { - unpack_int32(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_int32(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_INT_64: { - unpack_int64(user, load(n), obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_int64(user_, load(n), obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_BIN_8: case CS_RAW_8: trail = load(n); if(trail == 0) { - unpack_raw(user, data, n, trail, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_raw(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else { - cs = ACS_RAW_VALUE; + cs_ = ACS_RAW_VALUE; fixed_trail_again = true; } break; @@ -476,12 +472,12 @@ public: case CS_RAW_16: trail = load(n); if(trail == 0) { - unpack_raw(user, data, n, trail, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_raw(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else { - cs = ACS_RAW_VALUE; + cs_ = ACS_RAW_VALUE; fixed_trail_again = true; } break; @@ -489,50 +485,50 @@ public: case CS_RAW_32: trail = load(n); if(trail == 0) { - unpack_raw(user, data, n, trail, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_raw(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else { - cs = ACS_RAW_VALUE; + cs_ = ACS_RAW_VALUE; fixed_trail_again = true; } break; case ACS_RAW_VALUE: { - unpack_raw(user, data, n, trail, obj); - int ret = push_proc(stack, c, obj, p, data, off, top, cs, trail, user); + unpack_raw(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; case CS_ARRAY_16: { int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, stack, c, obj, p, n, data, off, top, cs, trail, user); + unpack_array(), CT_ARRAY_ITEM, c, obj, p, n, data, off, trail); if (ret != 0) return ret; } break; case CS_ARRAY_32: { /* FIXME security guard */ int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, stack, c, obj, p, n, data, off, top, cs, trail, user); + unpack_array(), CT_ARRAY_ITEM, c, obj, p, n, data, off, trail); if (ret != 0) return ret; } break; case CS_MAP_16: { int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, stack, c, obj, p, n, data, off, top, cs, trail, user); + unpack_map(), CT_MAP_KEY, c, obj, p, n, data, off, trail); if (ret != 0) return ret; } break; case CS_MAP_32: { /* FIXME security guard */ int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, stack, c, obj, p, n, data, off, top, cs, trail, user); + unpack_map(), CT_MAP_KEY, c, obj, p, n, data, off, trail); if (ret != 0) return ret; } break; default: - off = update_attributes(p, data, top, cs, trail, user); + off = update_attributes(p, data, trail); return -1; } } } while(p != pe); - off = update_attributes(p, data, top, cs, trail, user); + off = update_attributes(p, data, trail); return 0; } @@ -547,33 +543,29 @@ private: int push_aggregate( Func const& f, unsigned int ct, - template_unpack_stack* stack, template_unpack_stack*& c, object& obj, const char*& current, const char* load_pos, const char* origin, size_t& off, - unsigned int& top, - unsigned int& cs, - unsigned int trail, - unpack_user& user) { - if(top < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && f(user, load(load_pos), stack[top].obj())) { + unsigned int trail) { + if(top_ < MSGPACK_EMBED_STACK_SIZE /* FIXME */ + && f(user_, load(load_pos), stack_[top_].obj())) { if(load(load_pos) == 0) { - obj = stack[top].obj(); - int ret = push_proc(stack, c, obj, current, origin, off, top, cs, trail, user); + obj = stack_[top_].obj(); + int ret = push_proc(c, obj, current, origin, off, trail); if (ret != 0) return ret; } else { - stack[top].set_ct(ct); - stack[top].set_count(load(load_pos)); - ++top; - header_again(cs, current); + stack_[top_].set_ct(ct); + stack_[top_].set_count(load(load_pos)); + ++top_; + header_again(current); } } else { - off = update_attributes(current, origin, top, cs, trail, user); + off = update_attributes(current, origin, trail); return -1; } return 0; @@ -582,40 +574,29 @@ private: size_t update_attributes( const char* current, const char* origin, - unsigned int top, - unsigned int cs, - unsigned int trail, - unpack_user const& user) { + unsigned int trail) { trail_ = trail; - top_ = top; - cs_ = cs; - user_ = user; return current - origin; } - static void header_again(unsigned int& cs, const char*& current) { - cs = CS_HEADER; + void header_again(const char*& current) { + cs_ = CS_HEADER; ++current; } - static int push_item( - template_unpack_stack* stack, - template_unpack_stack*& c, - object& obj, - unsigned int top, - unpack_user& user) { + int push_item(template_unpack_stack*& c, object& obj) { bool finish = false; while (!finish) { - if(top == 0) { + if(top_ == 0) { return 1; } - c = &stack[top-1]; + c = &stack_[top_ - 1]; switch(c->ct()) { case CT_ARRAY_ITEM: - unpack_array_item(user, c->obj(), obj); + unpack_array_item(user_, c->obj(), obj); if(c->decl_count() == 0) { obj = c->obj(); - --top; - /*printf("stack pop %d\n", top);*/ + --top_; + /*printf("stack pop %d\n", top_);*/ } else { finish = true; @@ -627,11 +608,11 @@ private: finish = true; break; case CT_MAP_VALUE: - unpack_map_item(user, c->obj(), c->map_key(), obj); + unpack_map_item(user_, c->obj(), c->map_key(), obj); if(c->decl_count() == 0) { obj = c->obj(); - --top; - /*printf("stack pop %d\n", top);*/ + --top_; + /*printf("stack pop %d\n", top_);*/ } else { c->set_ct(CT_MAP_KEY); @@ -646,28 +627,24 @@ private: } int push_proc( - template_unpack_stack* stack, template_unpack_stack*& c, object& obj, const char*& current, const char* origin, size_t& off, - unsigned int top, - unsigned int& cs, - unsigned int trail, - unpack_user& user) { - int ret = push_item(stack, c, obj, top, user); + unsigned int trail) { + int ret = push_item(c, obj); if (ret > 0) { - stack[0].setObj(obj); + stack_[0].setObj(obj); ++current; /*printf("-- finish --\n"); */ - off = update_attributes(current, origin, top, cs, trail, user); + off = update_attributes(current, origin, trail); } else if (ret < 0) { - off = update_attributes(current, origin, top, cs, trail, user); + off = update_attributes(current, origin, trail); } else { - header_again(cs, current); + header_again(current); } return ret; } From fe82444db11ab5e3266aa2e3faaf67b627e12ca5 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 11 Sep 2013 11:21:11 +0900 Subject: [PATCH 041/153] Replaced NULL with nullptr. --- src/msgpack/type/define.hpp.erb | 2 +- src/msgpack/type/deque.hpp | 2 +- src/msgpack/type/list.hpp | 2 +- src/msgpack/type/map.hpp | 6 +++--- src/msgpack/type/raw.hpp | 2 +- src/msgpack/type/set.hpp | 4 ++-- src/msgpack/type/tr1/unordered_map.hpp | 4 ++-- src/msgpack/type/tr1/unordered_set.hpp | 4 ++-- src/msgpack/type/tuple.hpp.erb | 2 +- src/msgpack/type/vector.hpp | 2 +- src/msgpack/unpack.hpp | 16 ++++++++-------- src/msgpack/zbuffer.hpp | 6 +++--- 12 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb index bf1f4226..8a234256 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/src/msgpack/type/define.hpp.erb @@ -85,7 +85,7 @@ struct define<> { void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = NULL; + o->via.array.ptr = nullptr; o->via.array.size = 0; } }; diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp index a7c57b03..b3895f70 100644 --- a/src/msgpack/type/deque.hpp +++ b/src/msgpack/type/deque.hpp @@ -54,7 +54,7 @@ inline void operator<< (object::with_zone& o, const std::deque& v) { o.type = type::ARRAY; if(v.empty()) { - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } else { object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp index 30f78d62..03ae9d15 100644 --- a/src/msgpack/type/list.hpp +++ b/src/msgpack/type/list.hpp @@ -54,7 +54,7 @@ inline void operator<< (object::with_zone& o, const std::list& v) { o.type = type::ARRAY; if(v.empty()) { - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } else { object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp index 39d64a08..efbd5210 100644 --- a/src/msgpack/type/map.hpp +++ b/src/msgpack/type/map.hpp @@ -75,7 +75,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector& v) { o.type = type::MAP; if(v.empty()) { - o.via.map.ptr = NULL; + o.via.map.ptr = nullptr; o.via.map.size = 0; } else { object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); @@ -131,7 +131,7 @@ inline void operator<< (object::with_zone& o, const std::map& v) { o.type = type::MAP; if(v.empty()) { - o.via.map.ptr = NULL; + o.via.map.ptr = nullptr; o.via.map.size = 0; } else { object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); @@ -181,7 +181,7 @@ inline void operator<< (object::with_zone& o, const std::multimap& v) { o.type = type::MAP; if(v.empty()) { - o.via.map.ptr = NULL; + o.via.map.ptr = nullptr; o.via.map.size = 0; } else { object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); diff --git a/src/msgpack/type/raw.hpp b/src/msgpack/type/raw.hpp index efe2d21c..07aae119 100644 --- a/src/msgpack/type/raw.hpp +++ b/src/msgpack/type/raw.hpp @@ -27,7 +27,7 @@ namespace msgpack { namespace type { struct raw_ref { - raw_ref() : size(0), ptr(NULL) {} + raw_ref() : size(0), ptr(nullptr) {} raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {} uint32_t size; diff --git a/src/msgpack/type/set.hpp b/src/msgpack/type/set.hpp index 9b862131..506732e4 100644 --- a/src/msgpack/type/set.hpp +++ b/src/msgpack/type/set.hpp @@ -53,7 +53,7 @@ inline void operator<< (object::with_zone& o, const std::set& v) { o.type = type::ARRAY; if(v.empty()) { - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } else { object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); @@ -99,7 +99,7 @@ inline void operator<< (object::with_zone& o, const std::multiset& v) { o.type = type::ARRAY; if(v.empty()) { - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } else { object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp index 23168f4e..b652c3f6 100644 --- a/src/msgpack/type/tr1/unordered_map.hpp +++ b/src/msgpack/type/tr1/unordered_map.hpp @@ -74,7 +74,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m { o.type = type::MAP; if(v.empty()) { - o.via.map.ptr = NULL; + o.via.map.ptr = nullptr; o.via.map.size = 0; } else { object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); @@ -124,7 +124,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m { o.type = type::MAP; if(v.empty()) { - o.via.map.ptr = NULL; + o.via.map.ptr = nullptr; o.via.map.size = 0; } else { object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); diff --git a/src/msgpack/type/tr1/unordered_set.hpp b/src/msgpack/type/tr1/unordered_set.hpp index 63f37045..985dec6a 100644 --- a/src/msgpack/type/tr1/unordered_set.hpp +++ b/src/msgpack/type/tr1/unordered_set.hpp @@ -71,7 +71,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s { o.type = type::ARRAY; if(v.empty()) { - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } else { object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); @@ -117,7 +117,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m { o.type = type::ARRAY; if(v.empty()) { - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } else { object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index bf9cf8e0..6eb0cf5f 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -175,7 +175,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple<>& v) { o.type = type::ARRAY; - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } <%0.upto(GENERATION_LIMIT) {|i|%> diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp index 4cd1597e..03b9d198 100644 --- a/src/msgpack/type/vector.hpp +++ b/src/msgpack/type/vector.hpp @@ -58,7 +58,7 @@ inline void operator<< (object::with_zone& o, const std::vector& v) { o.type = type::ARRAY; if(v.empty()) { - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } else { object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 107b2a15..b14b522f 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -110,7 +110,7 @@ struct unpack_array { o.type = type::ARRAY; o.via.array.size = 0; o.via.array.ptr = (object*)u.z().malloc(n*sizeof(object)); - if(o.via.array.ptr == NULL) { return false; } + if(o.via.array.ptr == nullptr) { return false; } return true; } }; @@ -123,7 +123,7 @@ struct unpack_map { o.type = type::MAP; o.via.map.size = 0; o.via.map.ptr = (object_kv*)u.z().malloc(n*sizeof(object_kv)); - if(o.via.map.ptr == NULL) { return false; } + if(o.via.map.ptr == nullptr) { return false; } return true; } }; @@ -802,9 +802,9 @@ private: inline void unpack(unpacked& result, - const char* data, size_t len, size_t* offset = NULL); + const char* data, size_t len, size_t* offset = nullptr); inline void unpack(unpacked* result, - const char* data, size_t len, size_t* offset = NULL); + const char* data, size_t len, size_t* offset = nullptr); // obsolete typedef enum { @@ -822,8 +822,8 @@ static unpack_return unpack(const char* data, size_t len, size_t* off, // obsolete -static object unpack(const char* data, size_t len, zone& z, size_t* off = NULL); -static object unpack(const char* data, size_t len, zone* z, size_t* off = NULL); +static object unpack(const char* data, size_t len, zone& z, size_t* off = nullptr); +static object unpack(const char* data, size_t len, zone* z, size_t* off = nullptr); inline unpacker::unpacker(size_t initial_buffer_size) @@ -1081,7 +1081,7 @@ unpack_imp(const char* data, size_t len, size_t* off, zone& result_zone, object& result) { size_t noff = 0; - if(off != NULL) { noff = *off; } + if(off != nullptr) { noff = *off; } if(len <= noff) { // FIXME @@ -1099,7 +1099,7 @@ unpack_imp(const char* data, size_t len, size_t* off, return UNPACK_PARSE_ERROR; } - if(off != NULL) { *off = noff; } + if(off != nullptr) { *off = noff; } if(e == 0) { return UNPACK_CONTINUE; diff --git a/src/msgpack/zbuffer.hpp b/src/msgpack/zbuffer.hpp index 10c0077e..117bc498 100644 --- a/src/msgpack/zbuffer.hpp +++ b/src/msgpack/zbuffer.hpp @@ -122,8 +122,8 @@ public: char* release_buffer() { char* tmp = data_; - data_ = NULL; - stream_.next_out = NULL; + data_ = nullptr; + stream_.next_out = nullptr; stream_.avail_out = 0; return tmp; } @@ -136,7 +136,7 @@ private: size_t nsize = (csize == 0) ? init_size_ : csize * 2; char* tmp = static_cast(::realloc(data_, nsize)); - if(tmp == NULL) { + if(tmp == nullptr) { return false; } From 5fedaf285b4835f6c2e91f4c72d918c09c7015d8 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 11 Sep 2013 11:37:26 +0900 Subject: [PATCH 042/153] Removed C-style casts. --- src/msgpack/unpack.hpp | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index b14b522f..7cb30913 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -285,11 +285,11 @@ public: int selector = *reinterpret_cast(p); if (0) { } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum - unpack_uint8(user_, *(uint8_t*)p, obj); + unpack_uint8(user_, *reinterpret_cast(p), obj); int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum - unpack_int8(user_, *(int8_t*)p, obj); + unpack_int8(user_, *reinterpret_cast(p), obj); int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else if(0xc0 <= selector && selector <= 0xdf) { // Variable @@ -313,7 +313,7 @@ public: case 0xc4: // bin 8 case 0xc5: // bin 16 case 0xc6: // bin 32 - trail = 1 << (((unsigned int)*p) & 0x03); + trail = 1 << (static_cast(*p) & 0x03); cs_ = next_cs(p); fixed_trail_again = true; break; @@ -331,7 +331,7 @@ public: case 0xd1: // signed int 16 case 0xd2: // signed int 32 case 0xd3: // signed int 64 - trail = 1 << (((unsigned int)*p) & 0x03); + trail = 1 << (static_cast(*p) & 0x03); cs_ = next_cs(p); fixed_trail_again = true; break; @@ -343,7 +343,7 @@ public: case 0xd9: // raw 8 (str 8) case 0xda: // raw 16 (str 16) case 0xdb: // raw 32 (str 32) - trail = 1 << ((((unsigned int)*p) & 0x03) - 1); + trail = 1 << ((static_cast(*p) & 0x03) - 1); cs_ = next_cs(p); fixed_trail_again = true; break; @@ -351,7 +351,7 @@ public: case 0xdd: // array 32 case 0xde: // map 16 case 0xdf: // map 32 - trail = 2 << (((unsigned int)*p) & 0x01); + trail = 2 << (static_cast(*p) & 0x01); cs_ = next_cs(p); fixed_trail_again = true; break; @@ -360,7 +360,7 @@ public: return -1; } } else if(0xa0 <= selector && selector <= 0xbf) { // FixRaw - trail = (unsigned int)*p & 0x1f; + trail = static_cast(*p) & 0x1f; if(trail == 0) { unpack_raw(user_, data, n, trail, obj); int ret = push_proc(c, obj, p, data, off, trail); @@ -536,7 +536,7 @@ private: template static unsigned int next_cs(T p) { - return (unsigned int)*p & 0x1f; + return static_cast(*p) & 0x1f; } template @@ -832,7 +832,7 @@ inline unpacker::unpacker(size_t initial_buffer_size) initial_buffer_size = COUNTER_SIZE; } - char* buffer = (char*)::malloc(initial_buffer_size); + char* buffer = reinterpret_cast(::malloc(initial_buffer_size)); if(!buffer) { throw std::bad_alloc(); } @@ -889,7 +889,7 @@ inline void unpacker::expand_buffer(size_t size) next_size *= 2; } - char* tmp = (char*)::realloc(buffer_, next_size); + char* tmp = reinterpret_cast(::realloc(buffer_, next_size)); if(!tmp) { throw std::bad_alloc(); } @@ -904,7 +904,7 @@ inline void unpacker::expand_buffer(size_t size) next_size *= 2; } - char* tmp = (char*)::malloc(next_size); + char* tmp = reinterpret_cast(::malloc(next_size)); if(!tmp) { throw std::bad_alloc(); } From fade0644c72e2c84ae3213e9c83c1eeafd2e075d Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 11 Sep 2013 11:44:33 +0900 Subject: [PATCH 043/153] Added comments that how to compile and run it. --- example/speed_test.cc | 3 +++ 1 file changed, 3 insertions(+) diff --git a/example/speed_test.cc b/example/speed_test.cc index 1758ad5b..e410cd65 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -1,3 +1,6 @@ +// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system +// export LD_LIBRARY_PATH=path_to_boost_lib + #include #include #include From c375e14705138c053a1f869d488c4a6d00ed97ac Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 2 Oct 2013 17:28:30 +0900 Subject: [PATCH 044/153] Renamed a member function name from setObj to set_obj. --- src/msgpack/unpack.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 7cb30913..02779d6e 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -148,7 +148,7 @@ class template_unpack_stack { public: object const& obj() const { return obj_; } object& obj() { return obj_; } - void setObj(object const& obj) { obj_ = obj; } + void set_obj(object const& obj) { obj_ = obj; } size_t count() const { return count_; } void set_count(size_t count) { count_ = count; } size_t decl_count() { return --count_; } @@ -234,7 +234,7 @@ class template_context { public: template_context():trail_(0), cs_(CS_HEADER), top_(0) { - stack_[0].setObj(object()); + stack_[0].set_obj(object()); } void init() @@ -242,7 +242,7 @@ public: cs_ = CS_HEADER; trail_ = 0; top_ = 0; - stack_[0].setObj(object()); + stack_[0].set_obj(object()); } object const& data() const @@ -635,7 +635,7 @@ private: unsigned int trail) { int ret = push_item(c, obj); if (ret > 0) { - stack_[0].setObj(obj); + stack_[0].set_obj(obj); ++current; /*printf("-- finish --\n"); */ off = update_attributes(current, origin, trail); From e2026c0507783f3fcee136b3d945d8bc57fc6b1c Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 2 Oct 2013 17:37:09 +0900 Subject: [PATCH 045/153] Renamed the classes named template_*. Removed template_ from them because they are no longer template. --- src/msgpack/unpack.hpp | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 02779d6e..8e2cd186 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -144,7 +144,7 @@ inline void unpack_raw(unpack_user& u, const char* b, const char* p, unsigned in } -class template_unpack_stack { +class unpack_stack { public: object const& obj() const { return obj_; } object& obj() { return obj_; } @@ -230,9 +230,9 @@ inline T load(const char* n, typename msgpack::enable_if::type* (static_cast(reinterpret_cast(n)[7]) )); } -class template_context { +class context { public: - template_context():trail_(0), cs_(CS_HEADER), top_(0) + context():trail_(0), cs_(CS_HEADER), top_(0) { stack_[0].set_obj(object()); } @@ -272,7 +272,7 @@ public: unsigned int trail = trail_; object obj; - template_unpack_stack* c = nullptr; + unpack_stack* c = nullptr; if(p == pe) { off = update_attributes(p, data, trail); @@ -543,7 +543,7 @@ private: int push_aggregate( Func const& f, unsigned int ct, - template_unpack_stack*& c, + unpack_stack*& c, object& obj, const char*& current, const char* load_pos, @@ -583,7 +583,7 @@ private: cs_ = CS_HEADER; ++current; } - int push_item(template_unpack_stack*& c, object& obj) { + int push_item(unpack_stack*& c, object& obj) { bool finish = false; while (!finish) { if(top_ == 0) { @@ -627,7 +627,7 @@ private: } int push_proc( - template_unpack_stack*& c, + unpack_stack*& c, object& obj, const char*& current, const char* origin, @@ -654,7 +654,7 @@ private: unpack_user user_; unsigned int cs_; unsigned int top_; - template_unpack_stack stack_[MSGPACK_EMBED_STACK_SIZE]; + unpack_stack stack_[MSGPACK_EMBED_STACK_SIZE]; }; } // detail @@ -794,7 +794,7 @@ private: size_t parsed_; zone* z_; size_t initial_buffer_size_; - detail::template_context ctx_; + detail::context ctx_; private: unpacker(const unpacker&); @@ -1088,7 +1088,7 @@ unpack_imp(const char* data, size_t len, size_t* off, return UNPACK_CONTINUE; } - detail::template_context ctx; + detail::context ctx; ctx.init(); ctx.user().set_z(result_zone); From 74013e7e7dd15f98d261392672d1274a2215806b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 4 Oct 2013 13:14:15 +0900 Subject: [PATCH 046/153] Added array of array example. --- example/speed_test.cc | 76 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) diff --git a/example/speed_test.cc b/example/speed_test.cc index e410cd65..b8fb7ab1 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -60,10 +60,86 @@ void test_map_pack_unpack() { std::cout << "Convert finished..." << std::endl; } +template +struct vecvec { + typedef std::vector::type> type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + typename vecvec::type child; + vecvec::fill(child, num_of_elems, val); + v.push_back(child); + } + } +}; + +template +struct vecvec { + typedef std::vector type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + v.push_back(val); + } + } +}; + +void test_array_of_array() { + std::cout << "[TEST][array_of_array]" << std::endl; + // setup + int const depth = 16; + std::cout << "Setting up array data..." << std::endl; + typename vecvec::type v1; + vecvec::fill(v1, 3, 42); + + std::cout << "Start packing..." << std::endl; + std::stringstream buffer; + { + boost::timer::cpu_timer timer; + msgpack::pack(buffer, v1); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Pack finished..." << std::endl; + + buffer.seekg(0); + std::string str(buffer.str()); + + // deserialized object is valid during the msgpack::zone instance alive. + msgpack::zone mempool; + msgpack::object deserialized; + std::cout << "Start unpacking..." << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + + msgpack::unpacked unpacked; + std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(&unpacked, str.data(), str.size()); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + typename vecvec::type v2; + std::cout << "Start converting..." << std::endl; + { + boost::timer::cpu_timer timer; + deserialized.convert(&v2); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Convert finished..." << std::endl; +} + int main(void) { test_map_pack_unpack(); + test_array_of_array(); } From f187ae35d9ee8c3b9c5afc3ea29e9fe73b017f44 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 4 Oct 2013 13:45:06 +0900 Subject: [PATCH 047/153] Added a nested array example. --- example/speed_test.cc | 78 -------------------------- example/speed_test_nested_array.cc | 90 ++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+), 78 deletions(-) create mode 100644 example/speed_test_nested_array.cc diff --git a/example/speed_test.cc b/example/speed_test.cc index b8fb7ab1..e085c945 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -60,86 +60,8 @@ void test_map_pack_unpack() { std::cout << "Convert finished..." << std::endl; } -template -struct vecvec { - typedef std::vector::type> type; - static void fill(type& v, std::size_t num_of_elems, T const& val) { - for (int elem = 0; elem < num_of_elems; ++elem) { - typename vecvec::type child; - vecvec::fill(child, num_of_elems, val); - v.push_back(child); - } - } -}; - -template -struct vecvec { - typedef std::vector type; - static void fill(type& v, std::size_t num_of_elems, T const& val) { - for (int elem = 0; elem < num_of_elems; ++elem) { - v.push_back(val); - } - } -}; - -void test_array_of_array() { - std::cout << "[TEST][array_of_array]" << std::endl; - // setup - int const depth = 16; - std::cout << "Setting up array data..." << std::endl; - typename vecvec::type v1; - vecvec::fill(v1, 3, 42); - - std::cout << "Start packing..." << std::endl; - std::stringstream buffer; - { - boost::timer::cpu_timer timer; - msgpack::pack(buffer, v1); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Pack finished..." << std::endl; - - buffer.seekg(0); - std::string str(buffer.str()); - - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; - msgpack::object deserialized; - std::cout << "Start unpacking..." << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; - - msgpack::unpacked unpacked; - std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(&unpacked, str.data(), str.size()); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; - typename vecvec::type v2; - std::cout << "Start converting..." << std::endl; - { - boost::timer::cpu_timer timer; - deserialized.convert(&v2); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Convert finished..." << std::endl; -} - - - int main(void) { test_map_pack_unpack(); - test_array_of_array(); } diff --git a/example/speed_test_nested_array.cc b/example/speed_test_nested_array.cc new file mode 100644 index 00000000..714ead3b --- /dev/null +++ b/example/speed_test_nested_array.cc @@ -0,0 +1,90 @@ +// g++ -std=c++11 -O3 -g -Ipath_to_msgpack_src -Ipath_to_boost speed_test.cc -Lpath_to_boost_lib -lboost_timer -lboost_system +// export LD_LIBRARY_PATH=path_to_boost_lib + +#include +#include +#include +#include +#include +#include + +template +struct vecvec { + typedef std::vector::type> type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + typename vecvec::type child; + vecvec::fill(child, num_of_elems, val); + v.push_back(child); + } + } +}; + +template +struct vecvec { + typedef std::vector type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + v.push_back(val); + } + } +}; + +void test_array_of_array() { + std::cout << "[TEST][array_of_array]" << std::endl; + // setup + int const depth = 16; + std::cout << "Setting up array data..." << std::endl; + typename vecvec::type v1; + vecvec::fill(v1, 3, 42); + + std::cout << "Start packing..." << std::endl; + std::stringstream buffer; + { + boost::timer::cpu_timer timer; + msgpack::pack(buffer, v1); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Pack finished..." << std::endl; + + buffer.seekg(0); + std::string str(buffer.str()); + + // deserialized object is valid during the msgpack::zone instance alive. + msgpack::zone mempool; + msgpack::object deserialized; + std::cout << "Start unpacking..." << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + + msgpack::unpacked unpacked; + std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(&unpacked, str.data(), str.size()); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + typename vecvec::type v2; + std::cout << "Start converting..." << std::endl; + { + boost::timer::cpu_timer timer; + deserialized.convert(&v2); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Convert finished..." << std::endl; +} + +int main(void) +{ + test_array_of_array(); +} + From 293c839a2260791446549e1040ee097090b43ef3 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 30 Oct 2013 16:04:23 +0900 Subject: [PATCH 048/153] Supported 'plain' char. msgpack used to only support signed char and unsigned char. --- src/msgpack/type/int.hpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/msgpack/type/int.hpp b/src/msgpack/type/int.hpp index 5fa638fd..e70e2043 100644 --- a/src/msgpack/type/int.hpp +++ b/src/msgpack/type/int.hpp @@ -63,7 +63,7 @@ namespace detail { }; template - static inline T convert_integer(object o) + static inline T convert_integer(object const& o) { return detail::convert_integer_sign::value>::convert(o); } @@ -99,7 +99,7 @@ namespace detail { struct object_char_sign { static inline void make(object& o, char v) { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v - : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; + : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } }; @@ -152,10 +152,12 @@ inline unsigned long& operator>> (object const& o, unsigned long& v) inline unsigned long long& operator>> (object const& o, unsigned long long& v) { v = type::detail::convert_integer(o); return v; } + template inline packer& operator<< (packer& o, char v) { return type::detail::pack_char(o, v); } + template inline packer& operator<< (packer& o, signed char v) { o.pack_int8(v); return o; } @@ -234,6 +236,7 @@ inline void operator<< (object& o, unsigned long long v) { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + inline void operator<< (object::with_zone& o, char v) { static_cast(o) << v; } From 0d139318449592a44f199461d2bc6d49715cd13a Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 9 Dec 2013 21:37:35 +0000 Subject: [PATCH 049/153] Fixed freed memory accessing bug in the C++ code. (Issue #32) --- cpp11/zone.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index b7fbf5b4..07fd678b 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -133,6 +133,7 @@ private: ::free(c); c = n; } else { + head_ = c; break; } } From 33d3192ca264a2265f58c1089339e9ec053dd3ec Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 26 Dec 2013 10:55:13 +0900 Subject: [PATCH 050/153] Added static_cast to char. --- src/msgpack/pack.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index 5b5b0460..750818a8 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -558,7 +558,7 @@ inline packer& packer::pack_float(float d) union { float f; uint32_t i; } mem; mem.f = d; char buf[5]; - buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); + buf[0] = static_cast(0xca); _msgpack_store32(&buf[1], mem.i); append_buffer(buf, 5); return *this; } @@ -569,7 +569,7 @@ inline packer& packer::pack_double(double d) union { double f; uint64_t i; } mem; mem.f = d; char buf[9]; - buf[0] = 0xcb; + buf[0] = static_cast(0xcb); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); @@ -632,11 +632,11 @@ inline packer& packer::pack_map(size_t n) append_buffer(&buf, 1); } else if(n < 65536) { char buf[3]; - buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); + buf[0] = static_cast(0xde); _msgpack_store16(&buf[1], (uint16_t)n); append_buffer(buf, 3); } else { char buf[5]; - buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); + buf[0] = static_cast(0xdf); _msgpack_store32(&buf[1], (uint32_t)n); append_buffer(buf, 5); } return *this; From d70c44b723d8303adc6a2fefe088e96065941c83 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 26 Jan 2014 15:17:33 +0000 Subject: [PATCH 051/153] Added bin and str families support. --- example/simple.c | 4 +- src/msgpack/object.h | 15 +++-- src/msgpack/object.hpp | 44 +++++++++---- src/msgpack/pack.h | 7 ++- src/msgpack/pack.hpp | 41 +++++++++++-- src/msgpack/pack_template.h | 36 ++++++++++- src/msgpack/type/raw.hpp | 16 ++--- src/msgpack/type/string.hpp | 22 +++---- src/msgpack/unpack.hpp | 90 ++++++++++++++++++++------- src/msgpack/unpack_define.h | 9 +-- src/msgpack/unpack_template.h | 34 ++++++----- src/objectc.c | 33 +++++++--- src/unpack.c | 17 ++++-- test/msgpackc_test.cpp | 112 ++++++++++++++++++++++++++-------- test/streaming_c.cc | 34 ++++++++--- 15 files changed, 381 insertions(+), 133 deletions(-) diff --git a/example/simple.c b/example/simple.c index 41d8bb70..07fa2f8b 100644 --- a/example/simple.c +++ b/example/simple.c @@ -14,8 +14,8 @@ int main(void) msgpack_pack_array(&pk, 3); msgpack_pack_int(&pk, 1); msgpack_pack_true(&pk); - msgpack_pack_raw(&pk, 7); - msgpack_pack_raw_body(&pk, "example", 7); + msgpack_pack_str(&pk, 7); + msgpack_pack_str_body(&pk, "example", 7); /* deserialize the buffer into msgpack_object instance. */ /* deserialized object is valid during the msgpack_zone instance alive. */ diff --git a/src/msgpack/object.h b/src/msgpack/object.h index 4e840486..1f56c877 100644 --- a/src/msgpack/object.h +++ b/src/msgpack/object.h @@ -38,9 +38,10 @@ typedef enum { MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, MSGPACK_OBJECT_DOUBLE = 0x04, - MSGPACK_OBJECT_RAW = 0x05, + MSGPACK_OBJECT_STR = 0x05, MSGPACK_OBJECT_ARRAY = 0x06, - MSGPACK_OBJECT_MAP = 0x07 + MSGPACK_OBJECT_MAP = 0x07, + MSGPACK_OBJECT_BIN = 0x08 } msgpack_object_type; @@ -60,7 +61,12 @@ typedef struct { typedef struct { uint32_t size; const char* ptr; -} msgpack_object_raw; +} msgpack_object_str; + +typedef struct { + uint32_t size; + const char* ptr; +} msgpack_object_bin; typedef union { bool boolean; @@ -69,7 +75,8 @@ typedef union { double dec; msgpack_object_array array; msgpack_object_map map; - msgpack_object_raw raw; + msgpack_object_str str; + msgpack_object_bin bin; } msgpack_object_union; typedef struct msgpack_object { diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index 404e39d6..a622c100 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -40,7 +40,8 @@ namespace type { POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, DOUBLE = MSGPACK_OBJECT_DOUBLE, - RAW = MSGPACK_OBJECT_RAW, + STR = MSGPACK_OBJECT_STR, + BIN = MSGPACK_OBJECT_BIN, ARRAY = MSGPACK_OBJECT_ARRAY, MAP = MSGPACK_OBJECT_MAP }; @@ -60,7 +61,12 @@ struct object_map { object_kv* ptr; }; -struct object_raw { +struct object_str { + uint32_t size; + const char* ptr; +}; + +struct object_bin { uint32_t size; const char* ptr; }; @@ -73,8 +79,8 @@ struct object { double dec; object_array array; object_map map; - object_raw raw; - object_raw ref; // obsolete + object_str str; + object_bin bin; }; type::object_type type; @@ -228,9 +234,13 @@ inline bool operator==(const object& x, const object& y) case type::DOUBLE: return x.via.dec == y.via.dec; - case type::RAW: - return x.via.raw.size == y.via.raw.size && - memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0; + case type::STR: + return x.via.str.size == y.via.str.size && + memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; + + case type::BIN: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; case type::ARRAY: if(x.via.array.size != y.via.array.size) { @@ -424,9 +434,14 @@ packer& operator<< (packer& o, const object& v) o.pack_double(v.via.dec); return o; - case type::RAW: - o.pack_raw(v.via.raw.size); - o.pack_raw_body(v.via.raw.ptr, v.via.raw.size); + case type::STR: + o.pack_str(v.via.str.size); + o.pack_str_body(v.via.str.ptr, v.via.str.size); + return o; + + case type::BIN: + o.pack_bin(v.via.bin.size); + o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); return o; case type::ARRAY: @@ -476,10 +491,15 @@ std::ostream& operator<< (std::ostream& s, const object& o) s << o.via.dec; break; - case type::RAW: - (s << '"').write(o.via.raw.ptr, o.via.raw.size) << '"'; + case type::STR: + (s << '"').write(o.via.str.ptr, o.via.str.size) << '"'; break; + case type::BIN: + (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"'; + break; + + case type::ARRAY: s << "["; if(o.via.array.size != 0) { diff --git a/src/msgpack/pack.h b/src/msgpack/pack.h index 691a89d4..9735936c 100644 --- a/src/msgpack/pack.h +++ b/src/msgpack/pack.h @@ -94,8 +94,11 @@ static int msgpack_pack_array(msgpack_packer* pk, size_t n); static int msgpack_pack_map(msgpack_packer* pk, size_t n); -static int msgpack_pack_raw(msgpack_packer* pk, size_t l); -static int msgpack_pack_raw_body(msgpack_packer* pk, const void* b, size_t l); +static int msgpack_pack_str(msgpack_packer* pk, size_t l); +static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l); + +static int msgpack_pack_bin(msgpack_packer* pk, size_t l); +static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l); int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index 750818a8..c26e6ccf 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -77,8 +77,11 @@ public: packer& pack_map(size_t n); - packer& pack_raw(size_t l); - packer& pack_raw_body(const char* b, size_t l); + packer& pack_str(size_t l); + packer& pack_str_body(const char* b, size_t l); + + packer& pack_bin(size_t l); + packer& pack_bin_body(const char* b, size_t l); private: template @@ -643,12 +646,16 @@ inline packer& packer::pack_map(size_t n) } template -inline packer& packer::pack_raw(size_t l) +inline packer& packer::pack_str(size_t l) { if(l < 32) { unsigned char d = 0xa0 | (uint8_t)l; char buf = take8_8(d); append_buffer(&buf, 1); + } else if(l < 256) { + char buf[2]; + buf[0] = static_cast(0xd9); buf[1] = (uint8_t)l; + append_buffer(buf, 2); } else if(l < 65536) { char buf[3]; buf[0] = static_cast(0xda); _msgpack_store16(&buf[1], (uint16_t)l); @@ -662,7 +669,33 @@ inline packer& packer::pack_raw(size_t l) } template -inline packer& packer::pack_raw_body(const char* b, size_t l) +inline packer& packer::pack_str_body(const char* b, size_t l) +{ + append_buffer(b, l); + return *this; +} + +template +inline packer& packer::pack_bin(size_t l) +{ + if(l < 256) { + char buf[2]; + buf[0] = static_cast(0xc4); buf[1] = (uint8_t)l; + append_buffer(buf, 2); + } else if(l < 65536) { + char buf[3]; + buf[0] = static_cast(0xc5); _msgpack_store16(&buf[1], (uint16_t)l); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xc6); _msgpack_store32(&buf[1], (uint32_t)l); + append_buffer(buf, 5); + } + return *this; +} + +template +inline packer& packer::pack_bin_body(const char* b, size_t l) { append_buffer(b, l); return *this; diff --git a/src/msgpack/pack_template.h b/src/msgpack/pack_template.h index 0c975b47..2576a380 100644 --- a/src/msgpack/pack_template.h +++ b/src/msgpack/pack_template.h @@ -749,14 +749,18 @@ msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n) /* - * Raw + * Str */ -msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l) +msgpack_pack_inline_func(_str)(msgpack_pack_user x, size_t l) { if(l < 32) { unsigned char d = 0xa0 | (uint8_t)l; msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); + } else if(l < 256) { + unsigned char buf[2]; + buf[0] = 0xd9; buf[1] = (uint8_t)l; + msgpack_pack_append_buffer(x, buf, 2); } else if(l < 65536) { unsigned char buf[3]; buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); @@ -768,7 +772,33 @@ msgpack_pack_inline_func(_raw)(msgpack_pack_user x, size_t l) } } -msgpack_pack_inline_func(_raw_body)(msgpack_pack_user x, const void* b, size_t l) +msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l) +{ + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); +} + +/* + * Bin + */ + +msgpack_pack_inline_func(_bin)(msgpack_pack_user x, size_t l) +{ + if(l < 256) { + unsigned char buf[2]; + buf[0] = 0xc4; buf[1] = (uint8_t)l; + msgpack_pack_append_buffer(x, buf, 2); + } else if(l < 65536) { + unsigned char buf[3]; + buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l); + msgpack_pack_append_buffer(x, buf, 5); + } +} + +msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l) { msgpack_pack_append_buffer(x, (const unsigned char*)b, l); } diff --git a/src/msgpack/type/raw.hpp b/src/msgpack/type/raw.hpp index 07aae119..4f575f79 100644 --- a/src/msgpack/type/raw.hpp +++ b/src/msgpack/type/raw.hpp @@ -63,25 +63,25 @@ struct raw_ref { inline type::raw_ref& operator>> (object const& o, type::raw_ref& v) { - if(o.type != type::RAW) { throw type_error(); } - v.ptr = o.via.raw.ptr; - v.size = o.via.raw.size; + if(o.type != type::BIN) { throw type_error(); } + v.ptr = o.via.bin.ptr; + v.size = o.via.bin.size; return v; } template inline packer& operator<< (packer& o, const type::raw_ref& v) { - o.pack_raw(v.size); - o.pack_raw_body(v.ptr, v.size); + o.pack_bin(v.size); + o.pack_bin_body(v.ptr, v.size); return o; } inline void operator<< (object& o, const type::raw_ref& v) { - o.type = type::RAW; - o.via.raw.ptr = v.ptr; - o.via.raw.size = v.size; + o.type = type::BIN; + o.via.bin.ptr = v.ptr; + o.via.bin.size = v.size; } inline void operator<< (object::with_zone& o, const type::raw_ref& v) diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index 4dfe35c8..692f3921 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -26,33 +26,33 @@ namespace msgpack { inline std::string& operator>> (object const& o, std::string& v) { - if(o.type != type::RAW) { throw type_error(); } - v.assign(o.via.raw.ptr, o.via.raw.size); + if(o.type != type::BIN) { throw type_error(); } + v.assign(o.via.bin.ptr, o.via.bin.size); return v; } template inline packer& operator<< (packer& o, const std::string& v) { - o.pack_raw(v.size()); - o.pack_raw_body(v.data(), v.size()); + o.pack_bin(v.size()); + o.pack_bin_body(v.data(), v.size()); return o; } inline void operator<< (object::with_zone& o, const std::string& v) { - o.type = type::RAW; - char* ptr = static_cast(o.zone->malloc(v.size())); - o.via.raw.ptr = ptr; - o.via.raw.size = (uint32_t)v.size(); + o.type = type::BIN; + char* ptr = (char*)o.zone->malloc(v.size()); + o.via.bin.ptr = ptr; + o.via.bin.size = (uint32_t)v.size(); memcpy(ptr, v.data(), v.size()); } inline void operator<< (object& o, const std::string& v) { - o.type = type::RAW; - o.via.raw.ptr = v.data(); - o.via.raw.size = (uint32_t)v.size(); + o.type = type::BIN; + o.via.bin.ptr = v.data(); + o.via.bin.size = (uint32_t)v.size(); } diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 8e2cd186..07e599b6 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -135,11 +135,19 @@ inline void unpack_map_item(unpack_user&, object& c, object const& k, object con ++c.via.map.size; } -inline void unpack_raw(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) +inline void unpack_str(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) { - o.type = type::RAW; - o.via.raw.ptr = p; - o.via.raw.size = l; + o.type = type::STR; + o.via.str.ptr = p; + o.via.str.size = l; + u.set_referenced(true); +} + +inline void unpack_bin(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) +{ + o.type = type::BIN; + o.via.bin.ptr = p; + o.via.bin.size = l; u.set_referenced(true); } @@ -340,9 +348,9 @@ public: //case 0xd6: // big integer 16 //case 0xd7: // big integer 32 //case 0xd8: // big float 16 - case 0xd9: // raw 8 (str 8) - case 0xda: // raw 16 (str 16) - case 0xdb: // raw 32 (str 32) + case 0xd9: // str 8 + case 0xda: // str 16 + case 0xdb: // str 32 trail = 1 << ((static_cast(*p) & 0x03) - 1); cs_ = next_cs(p); fixed_trail_again = true; @@ -359,14 +367,14 @@ public: off = update_attributes(p, data, trail); return -1; } - } else if(0xa0 <= selector && selector <= 0xbf) { // FixRaw + } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr trail = static_cast(*p) & 0x1f; if(trail == 0) { - unpack_raw(user_, data, n, trail, obj); + unpack_str(user_, data, n, trail, obj); int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } - cs_ = ACS_RAW_VALUE; + cs_ = ACS_STR_VALUE; fixed_trail_again = true; } else if(0x90 <= selector && selector <= 0x9f) { // FixArray @@ -455,47 +463,85 @@ public: int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; - case CS_BIN_8: - case CS_RAW_8: + case CS_STR_8: trail = load(n); if(trail == 0) { - unpack_raw(user_, data, n, trail, obj); + unpack_str(user_, data, n, trail, obj); int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else { - cs_ = ACS_RAW_VALUE; + cs_ = ACS_STR_VALUE; + fixed_trail_again = true; + } + break; + case CS_BIN_8: + trail = load(n); + if(trail == 0) { + unpack_bin(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); + if (ret != 0) return ret; + } + else { + cs_ = ACS_BIN_VALUE; + fixed_trail_again = true; + } + break; + case CS_STR_16: + trail = load(n); + if(trail == 0) { + unpack_str(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); + if (ret != 0) return ret; + } + else { + cs_ = ACS_STR_VALUE; fixed_trail_again = true; } break; case CS_BIN_16: - case CS_RAW_16: trail = load(n); if(trail == 0) { - unpack_raw(user_, data, n, trail, obj); + unpack_bin(user_, data, n, trail, obj); int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else { - cs_ = ACS_RAW_VALUE; + cs_ = ACS_BIN_VALUE; + fixed_trail_again = true; + } + break; + case CS_STR_32: + trail = load(n); + if(trail == 0) { + unpack_str(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); + if (ret != 0) return ret; + } + else { + cs_ = ACS_STR_VALUE; fixed_trail_again = true; } break; case CS_BIN_32: - case CS_RAW_32: trail = load(n); if(trail == 0) { - unpack_raw(user_, data, n, trail, obj); + unpack_bin(user_, data, n, trail, obj); int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } else { - cs_ = ACS_RAW_VALUE; + cs_ = ACS_BIN_VALUE; fixed_trail_again = true; } break; - case ACS_RAW_VALUE: { - unpack_raw(user_, data, n, trail, obj); + case ACS_STR_VALUE: { + unpack_str(user_, data, n, trail, obj); + int ret = push_proc(c, obj, p, data, off, trail); + if (ret != 0) return ret; + } break; + case ACS_BIN_VALUE: { + unpack_bin(user_, data, n, trail, obj); int ret = push_proc(c, obj, p, data, off, trail); if (ret != 0) return ret; } break; diff --git a/src/msgpack/unpack_define.h b/src/msgpack/unpack_define.h index d9457940..edc60b61 100644 --- a/src/msgpack/unpack_define.h +++ b/src/msgpack/unpack_define.h @@ -66,9 +66,9 @@ typedef enum { //CS_FIXEXT_8 = 0x17, //CS_FIXEXT_16 = 0x18, - CS_RAW_8 = 0x19, // str8 - CS_RAW_16 = 0x1a, // str16 - CS_RAW_32 = 0x1b, // str32 + CS_STR_8 = 0x19, // str8 + CS_STR_16 = 0x1a, // str16 + CS_STR_32 = 0x1b, // str32 CS_ARRAY_16 = 0x1c, CS_ARRAY_32 = 0x1d, CS_MAP_16 = 0x1e, @@ -76,7 +76,8 @@ typedef enum { //ACS_BIG_INT_VALUE, //ACS_BIG_FLOAT_VALUE, - ACS_RAW_VALUE + ACS_STR_VALUE, + ACS_BIN_VALUE } msgpack_unpack_state; diff --git a/src/msgpack/unpack_template.h b/src/msgpack/unpack_template.h index 60611c6c..f84e9ac6 100644 --- a/src/msgpack/unpack_template.h +++ b/src/msgpack/unpack_template.h @@ -224,9 +224,9 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c //case 0xd6: // big integer 16 //case 0xd7: // big integer 32 //case 0xd8: // big float 16 - case 0xd9: // raw 8 (str 8) - case 0xda: // raw 16 (str 16) - case 0xdb: // raw 32 (str 32) + case 0xd9: // str 8 + case 0xda: // str 16 + case 0xdb: // str 32 again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); case 0xdc: // array 16 case 0xdd: // array 32 @@ -236,8 +236,8 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c default: goto _failed; } - SWITCH_RANGE(0xa0, 0xbf) // FixRaw - again_fixed_trail_if_zero(ACS_RAW_VALUE, ((unsigned int)*p & 0x1f), _raw_zero); + SWITCH_RANGE(0xa0, 0xbf) // FixStr + again_fixed_trail_if_zero(ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); SWITCH_RANGE(0x90, 0x9f) // FixArray start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM); SWITCH_RANGE(0x80, 0x8f) // FixMap @@ -308,18 +308,24 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c // // FIXME // push_variable_value(_big_float, data, n, trail); + case CS_STR_8: + again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero); case CS_BIN_8: - case CS_RAW_8: - again_fixed_trail_if_zero(ACS_RAW_VALUE, *(uint8_t*)n, _raw_zero); + again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); + case CS_STR_16: + again_fixed_trail_if_zero(ACS_STR_VALUE, _msgpack_load16(uint16_t,n), _str_zero); case CS_BIN_16: - case CS_RAW_16: - again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load16(uint16_t,n), _raw_zero); + again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load16(uint16_t,n), _bin_zero); + case CS_STR_32: + again_fixed_trail_if_zero(ACS_STR_VALUE, _msgpack_load32(uint32_t,n), _str_zero); case CS_BIN_32: - case CS_RAW_32: - again_fixed_trail_if_zero(ACS_RAW_VALUE, _msgpack_load32(uint32_t,n), _raw_zero); - case ACS_RAW_VALUE: - _raw_zero: - push_variable_value(_raw, data, n, trail); + again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load32(uint32_t,n), _bin_zero); + case ACS_STR_VALUE: + _str_zero: + push_variable_value(_str, data, n, trail); + case ACS_BIN_VALUE: + _bin_zero: + push_variable_value(_bin, data, n, trail); case CS_ARRAY_16: start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM); diff --git a/src/objectc.c b/src/objectc.c index 8634bcdf..903f101f 100644 --- a/src/objectc.c +++ b/src/objectc.c @@ -54,11 +54,18 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d) case MSGPACK_OBJECT_DOUBLE: return msgpack_pack_double(pk, d.via.dec); - case MSGPACK_OBJECT_RAW: + case MSGPACK_OBJECT_STR: { - int ret = msgpack_pack_raw(pk, d.via.raw.size); + int ret = msgpack_pack_str(pk, d.via.str.size); if(ret < 0) { return ret; } - return msgpack_pack_raw_body(pk, d.via.raw.ptr, d.via.raw.size); + return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size); + } + + case MSGPACK_OBJECT_BIN: + { + int ret = msgpack_pack_bin(pk, d.via.bin.size); + if(ret < 0) { return ret; } + return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); } case MSGPACK_OBJECT_ARRAY: @@ -122,9 +129,15 @@ void msgpack_object_print(FILE* out, msgpack_object o) fprintf(out, "%f", o.via.dec); break; - case MSGPACK_OBJECT_RAW: + case MSGPACK_OBJECT_STR: fprintf(out, "\""); - fwrite(o.via.raw.ptr, o.via.raw.size, 1, out); + fwrite(o.via.str.ptr, o.via.str.size, 1, out); + fprintf(out, "\""); + break; + + case MSGPACK_OBJECT_BIN: + fprintf(out, "\""); + fwrite(o.via.bin.ptr, o.via.bin.size, 1, out); fprintf(out, "\""); break; @@ -188,9 +201,13 @@ bool msgpack_object_equal(const msgpack_object x, const msgpack_object y) case MSGPACK_OBJECT_DOUBLE: return x.via.dec == y.via.dec; - case MSGPACK_OBJECT_RAW: - return x.via.raw.size == y.via.raw.size && - memcmp(x.via.raw.ptr, y.via.raw.ptr, x.via.raw.size) == 0; + case MSGPACK_OBJECT_STR: + return x.via.str.size == y.via.str.size && + memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; + + case MSGPACK_OBJECT_BIN: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; case MSGPACK_OBJECT_ARRAY: if(x.via.array.size != y.via.array.size) { diff --git a/src/unpack.c b/src/unpack.c index 8f154cac..005777e1 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -143,11 +143,20 @@ static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, return 0; } -static inline int template_callback_raw(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) +static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { - o->type = MSGPACK_OBJECT_RAW; - o->via.raw.ptr = p; - o->via.raw.size = l; + o->type = MSGPACK_OBJECT_STR; + o->via.str.ptr = p; + o->via.str.size = l; + u->referenced = true; + return 0; +} + +static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) +{ + o->type = MSGPACK_OBJECT_BIN; + o->via.bin.ptr = p; + o->via.bin.size = l; u->referenced = true; return 0; } diff --git a/test/msgpackc_test.cpp b/test/msgpackc_test.cpp index 589ac4eb..e8d00bed 100644 --- a/test/msgpackc_test.cpp +++ b/test/msgpackc_test.cpp @@ -417,20 +417,20 @@ TEST(MSGPACKC, simple_buffer_map) msgpack_sbuffer_destroy(&sbuf); } -TEST(MSGPACKC, simple_buffer_raw) +TEST(MSGPACKC, simple_buffer_str) { - unsigned int raw_size = 7; + unsigned int str_size = 7; msgpack_sbuffer sbuf; msgpack_sbuffer_init(&sbuf); msgpack_packer pk; msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_raw(&pk, raw_size); - msgpack_pack_raw_body(&pk, "fr", 2); - msgpack_pack_raw_body(&pk, "syuki", 5); + msgpack_pack_str(&pk, str_size); + msgpack_pack_str_body(&pk, "fr", 2); + msgpack_pack_str_body(&pk, "syuki", 5); // invalid data - msgpack_pack_raw_body(&pk, "", 0); - msgpack_pack_raw_body(&pk, "kzk", 0); + msgpack_pack_str_body(&pk, "", 0); + msgpack_pack_str_body(&pk, "kzk", 0); msgpack_zone z; msgpack_zone_init(&z, 2048); @@ -438,17 +438,37 @@ TEST(MSGPACKC, simple_buffer_raw) msgpack_unpack_return ret; ret = msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); msgpack_zone_destroy(&z); msgpack_sbuffer_destroy(&sbuf); } +TEST(MSGPACKC, unpack_fixstr) +{ + size_t str_size = 7; + const char buf[] = { + (char)0xa7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + }; + + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret; + ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); + + msgpack_zone_destroy(&z); +} + TEST(MSGPACKC, unpack_str8) { - size_t raw_size = 7; + size_t str_size = 7; const char buf[] = { (char)0xd9, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -459,16 +479,56 @@ TEST(MSGPACKC, unpack_str8) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); + + msgpack_zone_destroy(&z); +} + +TEST(MSGPACKC, unpack_str16) +{ + size_t str_size = 7; + const char buf[] = { + (char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + }; + + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret; + ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); + + msgpack_zone_destroy(&z); +} + +TEST(MSGPACKC, unpack_str32) +{ + size_t str_size = 7; + const char buf[] = { + (char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + }; + + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret; + ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(str_size, obj.via.str.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.str.ptr, str_size)); msgpack_zone_destroy(&z); } TEST(MSGPACKC, unpack_bin8) { - size_t raw_size = 7; + size_t bin_size = 7; const char buf[] = { (char)0xc4, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -479,16 +539,16 @@ TEST(MSGPACKC, unpack_bin8) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(bin_size, obj.via.bin.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); msgpack_zone_destroy(&z); } TEST(MSGPACKC, unpack_bin16) { - size_t raw_size = 7; + size_t bin_size = 7; const char buf[] = { (char)0xc5, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -499,16 +559,16 @@ TEST(MSGPACKC, unpack_bin16) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(bin_size, obj.via.bin.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); msgpack_zone_destroy(&z); } TEST(MSGPACKC, unpack_bin32) { - size_t raw_size = 7; + size_t bin_size = 7; const char buf[] = { (char)0xc6, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; @@ -519,9 +579,9 @@ TEST(MSGPACKC, unpack_bin32) msgpack_unpack_return ret; ret = msgpack_unpack(buf, sizeof(buf), NULL, &z, &obj); EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(raw_size, obj.via.raw.size); - EXPECT_EQ(0, memcmp("frsyuki", obj.via.raw.ptr, raw_size)); + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(bin_size, obj.via.bin.size); + EXPECT_EQ(0, memcmp("frsyuki", obj.via.bin.ptr, bin_size)); msgpack_zone_destroy(&z); } diff --git a/test/streaming_c.cc b/test/streaming_c.cc index 1b7ad8b6..bfd9f714 100644 --- a/test/streaming_c.cc +++ b/test/streaming_c.cc @@ -8,15 +8,20 @@ TEST(streaming, basic) msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - // 1, 2, 3, "raw", ["data"], {0.3: 0.4} + // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} EXPECT_EQ(0, msgpack_pack_int(pk, 1)); EXPECT_EQ(0, msgpack_pack_int(pk, 2)); EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - EXPECT_EQ(0, msgpack_pack_raw(pk, 3)); - EXPECT_EQ(0, msgpack_pack_raw_body(pk, "raw", 3)); + EXPECT_EQ(0, msgpack_pack_str(pk, 3)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_raw(pk, 4)); - EXPECT_EQ(0, msgpack_pack_raw_body(pk, "data", 4)); + EXPECT_EQ(0, msgpack_pack_str(pk, 8)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 1)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); EXPECT_EQ(0, msgpack_pack_map(pk, 1)); EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); @@ -67,17 +72,28 @@ TEST(streaming, basic) EXPECT_EQ(3, obj.via.u64); break; case 3: - EXPECT_EQ(MSGPACK_OBJECT_RAW, obj.type); - EXPECT_EQ(std::string("raw",3), std::string(obj.via.raw.ptr, obj.via.raw.size)); + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); break; case 4: EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); EXPECT_EQ(1, obj.via.array.size); e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_RAW, e.type); - EXPECT_EQ(std::string("data",4), std::string(e.via.raw.ptr, e.via.raw.size)); + EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); + EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); break; case 5: + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); + break; + case 6: + EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); + EXPECT_EQ(1, obj.via.array.size); + e = obj.via.array.ptr[0]; + EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); + EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); + break; + case 7: EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); EXPECT_EQ(1, obj.via.map.size); e = obj.via.map.ptr[0].key; From beebccd323ae9b6e9d5a59bf36c46508663b8b49 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 26 Jan 2014 22:18:26 +0000 Subject: [PATCH 052/153] Renamed zone::malloc familiy functions. --- cpp11/define.hpp | 2 +- cpp11/tuple.hpp | 2 +- cpp11/zone.hpp | 26 +++++++++++++------------- src/msgpack/type/define.hpp.erb | 2 +- src/msgpack/type/deque.hpp | 2 +- src/msgpack/type/list.hpp | 2 +- src/msgpack/type/map.hpp | 6 +++--- src/msgpack/type/pair.hpp | 2 +- src/msgpack/type/set.hpp | 4 ++-- src/msgpack/type/string.hpp | 2 +- src/msgpack/type/tr1/unordered_map.hpp | 4 ++-- src/msgpack/type/tr1/unordered_set.hpp | 4 ++-- src/msgpack/type/tuple.hpp.erb | 2 +- src/msgpack/type/vector.hpp | 2 +- src/msgpack/unpack.hpp | 4 ++-- src/msgpack/zone.hpp.erb | 26 +++++++++++++------------- test/zone.cc | 12 ++++++------ 17 files changed, 52 insertions(+), 52 deletions(-) diff --git a/cpp11/define.hpp b/cpp11/define.hpp index b29eb600..0f09c3aa 100644 --- a/cpp11/define.hpp +++ b/cpp11/define.hpp @@ -121,7 +121,7 @@ struct define { void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->malloc(sizeof(object)*sizeof...(Args))); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*sizeof...(Args))); o->via.array.size = sizeof...(Args); define_imp, sizeof...(Args)>::object(o, z, a); diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index 54724489..a747a759 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -189,7 +189,7 @@ inline void operator<< ( object::with_zone& o, type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->malloc(sizeof(object)*sizeof...(Args))); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); o.via.array.size = sizeof...(Args); TupleToObjectWithZone::convert(o, v); } diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index 07fd678b..c86a3304 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -155,8 +155,8 @@ public: public: static zone* create(size_t chunk_size); static void destroy(zone* zone); - void* malloc(size_t size); - void* malloc_no_align(size_t size); + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); void push_finalizer(void (*func)(void*), void* data); @@ -172,12 +172,12 @@ public: T* allocate(Args... args); private: - void undo_malloc(size_t size); + void undo_allocate(size_t size); template static void object_destructor(void* obj); - void* malloc_expand(size_t size); + void* allocate_expand(size_t size); }; inline zone* zone::create(size_t chunk_size) @@ -200,16 +200,16 @@ inline zone::zone(size_t chunk_size) noexcept:chunk_size_(chunk_size), chunk_lis { } -inline void* zone::malloc(size_t size) +inline void* zone::allocate_align(size_t size) { - return malloc_no_align( + return allocate_no_align( ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } -inline void* zone::malloc_no_align(size_t size) +inline void* zone::allocate_no_align(size_t size) { if(chunk_list_.free_ < size) { - return malloc_expand(size); + return allocate_expand(size); } char* ptr = chunk_list_.ptr_; @@ -219,7 +219,7 @@ inline void* zone::malloc_no_align(size_t size) return ptr; } -inline void* zone::malloc_expand(size_t size) +inline void* zone::allocate_expand(size_t size) { chunk_list* const cl = &chunk_list_; @@ -270,7 +270,7 @@ void zone::object_destructor(void* obj) reinterpret_cast(obj)->~T(); } -inline void zone::undo_malloc(size_t size) +inline void zone::undo_allocate(size_t size) { chunk_list_.ptr_ -= size; chunk_list_.free_ += size; @@ -280,18 +280,18 @@ inline void zone::undo_malloc(size_t size) template T* zone::allocate(Args... args) { - void* x = malloc(sizeof(T)); + void* x = allocate_align(sizeof(T)); try { finalizer_array_.push(&zone::object_destructor, x); } catch (...) { - undo_malloc(sizeof(T)); + undo_allocate(sizeof(T)); throw; } try { return new (x) T(args...); } catch (...) { --finalizer_array_.tail_; - undo_malloc(sizeof(T)); + undo_allocate(sizeof(T)); throw; } } diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb index 8a234256..fc233969 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/src/msgpack/type/define.hpp.erb @@ -118,7 +118,7 @@ struct define, A<%=j%><%}%>> { void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->malloc(sizeof(object)*<%=i+1%>)); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*<%=i+1%>)); o->via.array.size = <%=i+1%>; <%0.upto(i) {|j|%> o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%> diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp index b3895f70..be5ad8a4 100644 --- a/src/msgpack/type/deque.hpp +++ b/src/msgpack/type/deque.hpp @@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::deque& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp index 03ae9d15..f3ac18ba 100644 --- a/src/msgpack/type/list.hpp +++ b/src/msgpack/type/list.hpp @@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::list& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp index efbd5210..a4242b77 100644 --- a/src/msgpack/type/map.hpp +++ b/src/msgpack/type/map.hpp @@ -78,7 +78,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector& v) o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -134,7 +134,7 @@ inline void operator<< (object::with_zone& o, const std::map& v) o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -184,7 +184,7 @@ inline void operator<< (object::with_zone& o, const std::multimap& v) o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); diff --git a/src/msgpack/type/pair.hpp b/src/msgpack/type/pair.hpp index 1b9611e4..266abc72 100644 --- a/src/msgpack/type/pair.hpp +++ b/src/msgpack/type/pair.hpp @@ -47,7 +47,7 @@ template inline void operator<< (object::with_zone& o, const std::pair& v) { o.type = type::ARRAY; - object* p = static_cast(o.zone->malloc(sizeof(object)*2)); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*2)); o.via.array.ptr = p; o.via.array.size = 2; p[0] = object(v.first, o.zone); diff --git a/src/msgpack/type/set.hpp b/src/msgpack/type/set.hpp index 506732e4..cfb6e79a 100644 --- a/src/msgpack/type/set.hpp +++ b/src/msgpack/type/set.hpp @@ -56,7 +56,7 @@ inline void operator<< (object::with_zone& o, const std::set& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); @@ -102,7 +102,7 @@ inline void operator<< (object::with_zone& o, const std::multiset& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index 692f3921..836de2c6 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -42,7 +42,7 @@ inline packer& operator<< (packer& o, const std::string& v) inline void operator<< (object::with_zone& o, const std::string& v) { o.type = type::BIN; - char* ptr = (char*)o.zone->malloc(v.size()); + char* ptr = (char*)o.zone->allocate_align(v.size()); o.via.bin.ptr = ptr; o.via.bin.size = (uint32_t)v.size(); memcpy(ptr, v.data(), v.size()); diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp index b652c3f6..830561cb 100644 --- a/src/msgpack/type/tr1/unordered_map.hpp +++ b/src/msgpack/type/tr1/unordered_map.hpp @@ -77,7 +77,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -127,7 +127,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->malloc(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); diff --git a/src/msgpack/type/tr1/unordered_set.hpp b/src/msgpack/type/tr1/unordered_set.hpp index 985dec6a..c2b2ce8e 100644 --- a/src/msgpack/type/tr1/unordered_set.hpp +++ b/src/msgpack/type/tr1/unordered_set.hpp @@ -74,7 +74,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); @@ -120,7 +120,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index 6eb0cf5f..6159bc04 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -184,7 +184,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple, A<%=j%><%}%>>& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->malloc(sizeof(object)*<%=i+1%>)); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*<%=i+1%>)); o.via.array.size = <%=i+1%>; <%0.upto(i) {|j|%> o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%> diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp index 03b9d198..ac01b3c5 100644 --- a/src/msgpack/type/vector.hpp +++ b/src/msgpack/type/vector.hpp @@ -61,7 +61,7 @@ inline void operator<< (object::with_zone& o, const std::vector& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->malloc(sizeof(object)*v.size())); + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 07e599b6..0bda90f0 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -109,7 +109,7 @@ struct unpack_array { bool operator()(unpack_user&u, unsigned int n, object& o) const { o.type = type::ARRAY; o.via.array.size = 0; - o.via.array.ptr = (object*)u.z().malloc(n*sizeof(object)); + o.via.array.ptr = (object*)u.z().allocate_align(n*sizeof(object)); if(o.via.array.ptr == nullptr) { return false; } return true; } @@ -122,7 +122,7 @@ struct unpack_map { bool operator()(unpack_user& u, unsigned int n, object& o) const { o.type = type::MAP; o.via.map.size = 0; - o.via.map.ptr = (object_kv*)u.z().malloc(n*sizeof(object_kv)); + o.via.map.ptr = (object_kv*)u.z().allocate_align(n*sizeof(object_kv)); if(o.via.map.ptr == nullptr) { return false; } return true; } diff --git a/src/msgpack/zone.hpp.erb b/src/msgpack/zone.hpp.erb index 6c2ab0ab..35baf049 100644 --- a/src/msgpack/zone.hpp.erb +++ b/src/msgpack/zone.hpp.erb @@ -154,8 +154,8 @@ public: public: static zone* create(size_t chunk_size); static void destroy(zone* zone); - void* malloc(size_t size); - void* malloc_no_align(size_t size); + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); void push_finalizer(void (*func)(void*), void* data); @@ -172,12 +172,12 @@ public: <%}%> private: - void undo_malloc(size_t size); + void undo_allocate(size_t size); template static void object_destructor(void* obj); - void* malloc_expand(size_t size); + void* allocate_expand(size_t size); }; @@ -201,16 +201,16 @@ inline zone::zone(size_t chunk_size) /* throw() */ :chunk_size_(chunk_size), chu { } -inline void* zone::malloc(size_t size) +inline void* zone::allocate_align(size_t size) { - return malloc_no_align( + return allocate_no_align( ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } -inline void* zone::malloc_no_align(size_t size) +inline void* zone::allocate_no_align(size_t size) { if(chunk_list_.free_ < size) { - return malloc_expand(size); + return allocate_expand(size); } char* ptr = chunk_list_.ptr_; @@ -220,7 +220,7 @@ inline void* zone::malloc_no_align(size_t size) return ptr; } -inline void* zone::malloc_expand(size_t size) +inline void* zone::allocate_expand(size_t size) { chunk_list* const cl = &chunk_list_; @@ -271,7 +271,7 @@ void zone::object_destructor(void* obj) reinterpret_cast(obj)->~T(); } -inline void zone::undo_malloc(size_t size) +inline void zone::undo_allocate(size_t size) { chunk_list_.ptr_ -= size; chunk_list_.free_ += size; @@ -281,18 +281,18 @@ inline void zone::undo_malloc(size_t size) template , typename A<%=j%><%}%>> T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) { - void* x = malloc(sizeof(T)); + void* x = allocate_align(sizeof(T)); try { finalizer_array_.push(&zone::object_destructor, x); } catch (...) { - undo_malloc(sizeof(T)); + undo_allocate(sizeof(T)); throw; } try { return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); } catch (...) { --finalizer_array_.tail_; - undo_malloc(sizeof(T)); + undo_allocate(sizeof(T)); throw; } } diff --git a/test/zone.cc b/test/zone.cc index 5c771028..b364e3fb 100644 --- a/test/zone.cc +++ b/test/zone.cc @@ -1,12 +1,12 @@ #include #include -TEST(zone, malloc) +TEST(zone, allocate_align) { msgpack::zone z; - char* buf1 = (char*)z.malloc(4); + char* buf1 = (char*)z.allocate_align(4); memcpy(buf1, "test", 4); - char* buf2 = (char*)z.malloc(4); + char* buf2 = (char*)z.allocate_align(4); memcpy(buf2, "test", 4); } @@ -68,11 +68,11 @@ TEST(zone, push_finalizer_unique_ptr) } -TEST(zone, malloc_no_align) +TEST(zone, allocate_no_align) { msgpack::zone z; - char* buf1 = (char*)z.malloc_no_align(4); - char* buf2 = (char*)z.malloc_no_align(4); + char* buf1 = (char*)z.allocate_no_align(4); + char* buf2 = (char*)z.allocate_no_align(4); EXPECT_EQ(buf1+4, buf2); } From 6515577dc3cca271224ea9503f2d02b1b08feb05 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 2 Feb 2014 17:28:33 +0000 Subject: [PATCH 053/153] Added null pointer check for C++ separated code. --- cpp11/zone.hpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index c86a3304..a5635450 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -230,8 +230,13 @@ inline void* zone::allocate_expand(size_t size) } chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if (!c) return nullptr; char* ptr = reinterpret_cast(c) + sizeof(chunk); + if (!ptr) { + ::free(c); + return nullptr; + } c->next_ = cl->head_; cl->head_ = c; From bff4cadeffb79370d69f7e494138c533f3fcb9b7 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 2 Feb 2014 17:41:48 +0000 Subject: [PATCH 054/153] Added C++ separate version and C++11 description. --- README.md | 41 +++++++++++------------------------------ 1 file changed, 11 insertions(+), 30 deletions(-) diff --git a/README.md b/README.md index a9621f1b..c16c7b88 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,7 @@ MessagePack is an efficient binary serialization format. It lets you exchange da ## License -Msgpack is Copyright (C) 2008-2010 FURUHASHI Sadayuki and licensed under the Apache License, Version 2.0 (the "License"). For details see the `COPYING` file in this directory. +Msgpack is Copyright (C) 2008-2014 FURUHASHI Sadayuki and licensed under the Apache License, Version 2.0 (the "License"). For details see the `COPYING` file in this directory. ## Contributing @@ -29,8 +29,11 @@ To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack ##### Using autotools You will need gcc (4.1.0 or higher), autotools. +You can use msgpack-c as a header only library on C++11 and C++03. +You don't need to prepare ruby when you choose C++11 configuration. +For C++11: ``` -$ git clone https://github.com/msgpack/msgpack-c.git +$ git clone https://github.com/redboltz/msgpack-c/tree/cxx_separate $ cd msgpack-c $ ./bootstrap $ ./configure @@ -70,39 +73,20 @@ You need the compiler that fully supports C++11. #### Install from package -##### UNIX-like platform with ./configure - -On typical UNIX-like platforms, download source package from [Releases](https://github.com/msgpack/msgpack-c/releases) and run `./configure && make && make install`. Example: +Add msgpack-c/src to your include path. +``` +For C++03: ``` $ wget https://github.com/msgpack/msgpack-c/releases/download/cpp-0.5.9/msgpack-0.5.9.tar.gz $ tar zxvf msgpack-0.5.9.tar.gz $ cd msgpack-0.5.9 $ ./configure -$ make -$ sudo make install + +Add msgpack-c/src to your include path. ``` -##### FreeBSD with Ports Collection - -On FreeBSD, you can use Ports Collection. Install [net/msgpack](http://www.freebsd.org/cgi/cvsweb.cgi/ports/devel/msgpack/) package. - -##### Gentoo Linux with Portage - -On Gentoo Linux, you can use emerge. Install [dev-libs/msgpack](http://gentoo-portage.com/dev-libs/msgpack) package. - -##### Mac OS X with MacPorts - -On Mac OS X, you can install MessagePack for C using MacPorts. - -``` -$ sudo port install msgpack -``` - -You might need to run `sudo port selfupdate` before installing to update the package repository. - -You can also install via Homebrew. - +For C: ``` $ sudo brew install msgpack ``` @@ -174,6 +158,3 @@ int main() { obj.as(); // type is mismatched, msgpack::type_error is thrown } ``` -### Quickstart Guides - -For more detailed examples see [QuickStart for C](QUICKSTART-C.md) and [QuickStart for C++](QUICKSTART-CPP.md). From a20594dfdc2229ea5c3fee5425d09901efe4f78e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 2 Feb 2014 17:57:44 +0000 Subject: [PATCH 055/153] Added line breaks. --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index c16c7b88..c512eb6d 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,9 @@ To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack You will need gcc (4.1.0 or higher), autotools. You can use msgpack-c as a header only library on C++11 and C++03. + You don't need to prepare ruby when you choose C++11 configuration. + For C++11: ``` $ git clone https://github.com/redboltz/msgpack-c/tree/cxx_separate From 13404a7444704995b985c0099d97bed002b02c44 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 20 Feb 2014 23:53:35 +0000 Subject: [PATCH 056/153] Supported placement new. --- src/msgpack/zone.hpp.erb | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/src/msgpack/zone.hpp.erb b/src/msgpack/zone.hpp.erb index 35baf049..28382b21 100644 --- a/src/msgpack/zone.hpp.erb +++ b/src/msgpack/zone.hpp.erb @@ -165,7 +165,24 @@ public: void clear(); void swap(zone& o); - + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t size, void* place) throw() + { + return ::operator new(size, place); + } + static void operator delete(void* p, void* place) throw() + { + ::operator delete(p, place); + } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); From 723d90009849bbc1c037a663d3a572adc53e49d8 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 20 Feb 2014 23:55:22 +0000 Subject: [PATCH 057/153] Added 'template' keyword. --- src/msgpack/type/tuple.hpp.erb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb index 6159bc04..d5ff3e0c 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/src/msgpack/type/tuple.hpp.erb @@ -113,10 +113,10 @@ struct tuple, A<%=j%><%}%>> { template , typename A<%=j%><%}%>> inline typename type::tuple_element, A<%=j%><%}%>>, N>::reference get(type::tuple, A<%=j%><%}%>>& t) -{ return t.get(); } +{ return t.template get(); } template , typename A<%=j%><%}%>> inline typename type::const_tuple_element, A<%=j%><%}%>>, N>::const_reference get(type::tuple, A<%=j%><%}%>> const& t) -{ return t.get(); } +{ return t.template get(); } <%}%> inline tuple<> make_tuple() From 2be892bfda98b0a765f4ae8046ede7e132344dc1 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 3 Feb 2014 11:07:26 +0900 Subject: [PATCH 058/153] Removed a redundant null pointer check. --- cpp11/zone.hpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index a5635450..a152ae87 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -233,10 +233,6 @@ inline void* zone::allocate_expand(size_t size) if (!c) return nullptr; char* ptr = reinterpret_cast(c) + sizeof(chunk); - if (!ptr) { - ::free(c); - return nullptr; - } c->next_ = cl->head_; cl->head_ = c; From ed51d2333515a228424e1dc4a80d388760782aa9 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 4 Mar 2014 21:27:47 +0000 Subject: [PATCH 059/153] Refined tuple implementation. --- cpp11/tuple.hpp | 85 ++++++++++++++++++------------------------- test/msgpack_tuple.cc | 23 ++++-------- 2 files changed, 43 insertions(+), 65 deletions(-) diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp index a747a759..1d068a37 100644 --- a/cpp11/tuple.hpp +++ b/cpp11/tuple.hpp @@ -32,76 +32,61 @@ namespace type { using std::tuple_element; using std::uses_allocator; using std::ignore; + using std::make_tuple; + using std::tie; + using std::forward_as_tuple; + using std::swap; template< class... Types > class tuple : public std::tuple { public: - using std::tuple::tuple; + using base = std::tuple; + + using base::tuple; + + tuple() = default; + tuple(tuple const&) = default; + tuple(tuple&&) = default; + + template + tuple(tuple const& other):base(static_cast const&>(other)) {} + template + tuple(tuple && other):base(static_cast &&>(other)) {} + + tuple& operator=(tuple const&) = default; + tuple& operator=(tuple&&) = default; + + template + tuple& operator=(tuple const& other) { + *static_cast(this) = static_cast const&>(other); + return *this; + } + template + tuple& operator=(tuple && other) { + *static_cast(this) = static_cast &&>(other); + return *this; + } template< std::size_t I> - typename tuple_element >::type& + typename tuple_element::type& get() { return std::get(*this); } template< std::size_t I> - typename tuple_element >::type const& + typename tuple_element::type const& get() const { return std::get(*this); } template< std::size_t I> - typename tuple_element >::type&& + typename tuple_element::type&& get() && { return std::get(*this); } }; - template< class... Types > - tuple make_tuple( Types&&... args ) { - return tuple(std::forward(args)...); - } - - template< class... Types > - tuple make_tuple( std::tuple&& arg ) { - return tuple(std::forward&&>(arg)); - } - - template< class... Types > - tuple tie( Types&... args ) { - return std::tie(args...); - } - - template< class... Types > - tuple forward_as_tuple( Types&&... args ) { - return std::forward_as_tuple(std::forward(args)...); - } - - namespace detail { - template < typename... Types > - std::tuple&& get_std_tuple(tuple&& t) { - return std::forward&&>(t); - } - template < typename... Types > - std::tuple& get_std_tuple(tuple& t) { - return t; - } - template < typename... Types > - std::tuple const& get_std_tuple(tuple const& t) { - return t; - } - template < typename T > - T&& get_std_tuple(T&& t) { - return t; - } - } template< class... Tuples > auto tuple_cat(Tuples&&... args) -> decltype( - msgpack::type::make_tuple(std::tuple_cat(detail::get_std_tuple(std::forward(args))...)) + std::tuple_cat(std::forward::type::base>(args)...) ) { - return std::tuple_cat(detail::get_std_tuple(std::forward(args))...); + return std::tuple_cat(std::forward::type::base>(args)...); } - - template< class... Types > - void swap( tuple& lhs, tuple& rhs ) { - lhs.swap(rhs); - } - } // namespace type // --- Pack ( from tuple to packer stream --- diff --git a/test/msgpack_tuple.cc b/test/msgpack_tuple.cc index b5a7e8f3..2b11a83e 100644 --- a/test/msgpack_tuple.cc +++ b/test/msgpack_tuple.cc @@ -61,8 +61,7 @@ TEST(msgpack_tuple, make_tuple) TEST(msgpack_tuple, std_make_tuple) { - msgpack::type::tuple t1 = - msgpack::type::make_tuple(std::make_tuple(42, true, "ABC")); + msgpack::type::tuple t1 = std::make_tuple(42, true, "ABC"); EXPECT_EQ(42, t1.get<0>()); EXPECT_EQ(true, t1.get<1>()); EXPECT_EQ("ABC", t1.get<2>()); @@ -70,19 +69,13 @@ TEST(msgpack_tuple, std_make_tuple) TEST(msgpack_tuple, tie) { - int i(42); - bool b(true); - std::string s("ABC"); - msgpack::type::tuple t1 = msgpack::type::tie(i, b, s); - EXPECT_EQ(42, t1.get<0>()); - EXPECT_EQ(true, t1.get<1>()); - EXPECT_EQ("ABC", t1.get<2>()); - t1.get<0>() = 40; - t1.get<1>() = false; - t1.get<2>() = "DEFG"; - EXPECT_EQ(40, t1.get<0>()); - EXPECT_EQ(false, t1.get<1>()); - EXPECT_EQ("DEFG", t1.get<2>()); + int i(43); + bool b(false); + std::string s("DEFG"); + msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, i); + EXPECT_EQ(true, b); + EXPECT_EQ("ABC", s); } TEST(msgpack_tuple, tuple_cat) From 59d994ea5fd5a83e51c4aed7ac6d75da24a0d42b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 4 Mar 2014 21:28:28 +0000 Subject: [PATCH 060/153] Define nullptr macro only if it is not previously defined. --- src/msgpack/cpp_config.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/msgpack/cpp_config.hpp b/src/msgpack/cpp_config.hpp index 8db6d25b..596bef9d 100644 --- a/src/msgpack/cpp_config.hpp +++ b/src/msgpack/cpp_config.hpp @@ -21,7 +21,9 @@ #if defined __cplusplus #if __cplusplus < 201103 +#if !defined(nullptr) #define nullptr (0) +#endif namespace msgpack { From c08439ff4161206a3b75d7181e5cad8a9549b447 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 4 Mar 2014 15:14:11 +0900 Subject: [PATCH 061/153] Added STR to std::string conversion. --- src/msgpack/type/string.hpp | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index 836de2c6..d072d861 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -26,8 +26,17 @@ namespace msgpack { inline std::string& operator>> (object const& o, std::string& v) { - if(o.type != type::BIN) { throw type_error(); } - v.assign(o.via.bin.ptr, o.via.bin.size); + switch (o.type) { + case type::BIN: + v.assign(o.via.bin.ptr, o.via.bin.size); + break; + case type::STR: + v.assign(o.via.str.ptr, o.via.str.size); + break; + default: + throw type_error(); + break; + } return v; } From 038c3e3518a22f3ed9d289b0568a3bd83decae46 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 5 Mar 2014 00:44:15 +0000 Subject: [PATCH 062/153] Replaced unsigned int to size_t. --- src/msgpack/pack.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index c26e6ccf..7010d4e3 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -101,7 +101,7 @@ private: template void pack_imp_int64(T d); - void append_buffer(const char* buf, unsigned int len) + void append_buffer(const char* buf, size_t len) { m_stream.write(buf, len); } private: From 3b7a2f8f32d594d2be19b0472e794e953394fcca Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 5 Mar 2014 11:53:06 +0900 Subject: [PATCH 063/153] Updated test codes using reference version of unpack functions. --- test/msgpack_test.cpp | 50 +++++++++++++++++++++---------------------- test/object.cc | 4 ++-- test/pack_unpack.cc | 8 +++---- 3 files changed, 31 insertions(+), 31 deletions(-) diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index d9a40500..bacf6de3 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,7 +38,7 @@ const double kEPS = 1e-10; msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ @@ -165,7 +165,7 @@ TEST(MSGPACK, simple_buffer_float) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float val2; obj.convert(&val2); @@ -255,7 +255,7 @@ TEST(MSGPACK, simple_buffer_double) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); double val2; obj.convert(&val2); @@ -277,7 +277,7 @@ TEST(MSGPACK, simple_buffer_true) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -292,7 +292,7 @@ TEST(MSGPACK, simple_buffer_false) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -314,7 +314,7 @@ TEST(MSGPACK_STL, simple_buffer_string) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); string val2; obj.convert(&val2); @@ -334,7 +334,7 @@ TEST(MSGPACK_STL, simple_buffer_vector) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); vector val2; obj.convert(&val2); @@ -354,7 +354,7 @@ TEST(MSGPACK_STL, simple_buffer_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); map val2; obj.convert(&val2); @@ -374,7 +374,7 @@ TEST(MSGPACK_STL, simple_buffer_deque) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); deque val2; obj.convert(&val2); @@ -394,7 +394,7 @@ TEST(MSGPACK_STL, simple_buffer_list) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); list val2; obj.convert(&val2); @@ -414,7 +414,7 @@ TEST(MSGPACK_STL, simple_buffer_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); set val2; obj.convert(&val2); @@ -432,7 +432,7 @@ TEST(MSGPACK_STL, simple_buffer_pair) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); pair val2; obj.convert(&val2); @@ -455,7 +455,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multimap val2; obj.convert(&val2); @@ -485,7 +485,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multiset val2; obj.convert(&val2); @@ -520,7 +520,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_map val2; obj.convert(&val2); @@ -547,7 +547,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multimap val2; obj.convert(&val2); @@ -581,7 +581,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_set val2; obj.convert(&val2); @@ -603,7 +603,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multiset val2; obj.convert(&val2); @@ -760,7 +760,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -793,7 +793,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass2 val2; val2.i = -1; @@ -815,7 +815,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -856,7 +856,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestEnumMemberClass val2; val2.t1 = TestEnumMemberClass::STATE_INVALID; @@ -919,7 +919,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -934,7 +934,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -962,7 +962,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ diff --git a/test/object.cc b/test/object.cc index 5390c4ae..7a6b0a87 100644 --- a/test/object.cc +++ b/test/object.cc @@ -37,7 +37,7 @@ TEST(object, convert) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); myclass m2; @@ -58,7 +58,7 @@ TEST(object, as) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(m1, obj.as()); diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index ac47f2d9..6718a01b 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -60,7 +60,7 @@ TEST(unpack, myclass) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj); + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); @@ -105,17 +105,17 @@ TEST(unpack, sequence_compat) msgpack::object obj; msgpack::unpack_return ret; - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(1, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(2, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(3, obj.as()); From a951ea90b85700d4bb83ee94ff915f4005abb73d Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 15 Mar 2014 17:37:20 +0000 Subject: [PATCH 064/153] Fixed delete free mismatch problem in C++11 version. --- cpp11/zone.hpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp index a152ae87..9a99e650 100644 --- a/cpp11/zone.hpp +++ b/cpp11/zone.hpp @@ -168,6 +168,24 @@ public: void swap(zone& o); + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t size, void* mem) throw() + { + return mem; + } + static void operator delete(void *p, void* mem) throw() + { + } + template T* allocate(Args... args); From 1320863cb3be9ec19f11d478e2485a3ea4fe7570 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 24 Mar 2014 15:16:37 +0900 Subject: [PATCH 065/153] Replaced function arguments with data members. --- src/msgpack/unpack.hpp | 234 +++++++++++++++++++---------------------- 1 file changed, 109 insertions(+), 125 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 0bda90f0..a42bffcd 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -272,57 +272,55 @@ public: { assert(len >= off); - const char* p = data + off; + start_ = data; + current_ = data + off; + stack_idx_ = 0; const char* const pe = data + len; const char* n = nullptr; - // to support register optimization - unsigned int trail = trail_; - object obj; - unpack_stack* c = nullptr; - if(p == pe) { - off = update_attributes(p, data, trail); + if(current_ == pe) { + off = current_ - start_; return 0; } bool fixed_trail_again = false; do { if (cs_ == CS_HEADER) { fixed_trail_again = false; - int selector = *reinterpret_cast(p); + int selector = *reinterpret_cast(current_); if (0) { } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum - unpack_uint8(user_, *reinterpret_cast(p), obj); - int ret = push_proc(c, obj, p, data, off, trail); + unpack_uint8(user_, *reinterpret_cast(current_), obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum - unpack_int8(user_, *reinterpret_cast(p), obj); - int ret = push_proc(c, obj, p, data, off, trail); + unpack_int8(user_, *reinterpret_cast(current_), obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else if(0xc0 <= selector && selector <= 0xdf) { // Variable switch(selector) { case 0xc0: { // nil unpack_nil(user_, obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; //case 0xc1: // string case 0xc2: { // false unpack_false(user_, obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case 0xc3: { // true unpack_true(user_, obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case 0xc4: // bin 8 case 0xc5: // bin 16 case 0xc6: // bin 32 - trail = 1 << (static_cast(*p) & 0x03); - cs_ = next_cs(p); + trail_ = 1 << (static_cast(*current_) & 0x03); + cs_ = next_cs(current_); fixed_trail_again = true; break; @@ -339,8 +337,8 @@ public: case 0xd1: // signed int 16 case 0xd2: // signed int 32 case 0xd3: // signed int 64 - trail = 1 << (static_cast(*p) & 0x03); - cs_ = next_cs(p); + trail_ = 1 << (static_cast(*current_) & 0x03); + cs_ = next_cs(current_); fixed_trail_again = true; break; //case 0xd4: @@ -351,27 +349,27 @@ public: case 0xd9: // str 8 case 0xda: // str 16 case 0xdb: // str 32 - trail = 1 << ((static_cast(*p) & 0x03) - 1); - cs_ = next_cs(p); + trail_ = 1 << ((static_cast(*current_) & 0x03) - 1); + cs_ = next_cs(current_); fixed_trail_again = true; break; case 0xdc: // array 16 case 0xdd: // array 32 case 0xde: // map 16 case 0xdf: // map 32 - trail = 2 << (static_cast(*p) & 0x01); - cs_ = next_cs(p); + trail_ = 2 << (static_cast(*current_) & 0x01); + cs_ = next_cs(current_); fixed_trail_again = true; break; default: - off = update_attributes(p, data, trail); + off = current_ - start_; return -1; } } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr - trail = static_cast(*p) & 0x1f; - if(trail == 0) { - unpack_str(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + trail_ = static_cast(*current_) & 0x1f; + if(trail_ == 0) { + unpack_str(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } cs_ = ACS_STR_VALUE; @@ -379,29 +377,29 @@ public: } else if(0x90 <= selector && selector <= 0x9f) { // FixArray int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, c, obj, p, p, data, off, trail); + unpack_array(), CT_ARRAY_ITEM, obj, current_, off); if (ret != 0) return ret; } else if(0x80 <= selector && selector <= 0x8f) { // FixMap int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, c, obj, p, p, data, off, trail); + unpack_map(), CT_MAP_KEY, obj, current_, off); if (ret != 0) return ret; } else { - off = update_attributes(p, data, trail); + off = current_ - start_; return -1; } // end CS_HEADER } if (cs_ != CS_HEADER || fixed_trail_again) { if (fixed_trail_again) { - ++p; + ++current_; fixed_trail_again = false; } - if((size_t)(pe - p) < trail) { - off = update_attributes(p, data, trail); + if((size_t)(pe - current_) < trail_) { + off = current_ - start_; return 0; } - n = p; - p += trail - 1; + n = current_; + current_ += trail_ - 1; switch(cs_) { //case CS_ //case CS_ @@ -409,7 +407,7 @@ public: union { uint32_t i; float f; } mem; mem.i = load(n); unpack_float(user_, mem.f, obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_DOUBLE: { @@ -420,54 +418,54 @@ public: mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif unpack_double(user_, mem.f, obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_8: { unpack_uint8(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_16: { unpack_uint16(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_32: { unpack_uint32(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_64: { unpack_uint64(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_8: { unpack_int8(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_16: { unpack_int16(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_32: { unpack_int32(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_64: { unpack_int64(user_, load(n), obj); - int ret = push_proc(c, obj, p, data, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_STR_8: - trail = load(n); - if(trail == 0) { - unpack_str(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + trail_ = load(n); + if(trail_ == 0) { + unpack_str(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else { @@ -476,10 +474,10 @@ public: } break; case CS_BIN_8: - trail = load(n); - if(trail == 0) { - unpack_bin(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + trail_ = load(n); + if(trail_ == 0) { + unpack_bin(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else { @@ -488,10 +486,10 @@ public: } break; case CS_STR_16: - trail = load(n); - if(trail == 0) { - unpack_str(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + trail_ = load(n); + if(trail_ == 0) { + unpack_str(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else { @@ -500,10 +498,10 @@ public: } break; case CS_BIN_16: - trail = load(n); - if(trail == 0) { - unpack_bin(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + trail_ = load(n); + if(trail_ == 0) { + unpack_bin(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else { @@ -512,10 +510,10 @@ public: } break; case CS_STR_32: - trail = load(n); - if(trail == 0) { - unpack_str(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + trail_ = load(n); + if(trail_ == 0) { + unpack_str(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else { @@ -524,10 +522,10 @@ public: } break; case CS_BIN_32: - trail = load(n); - if(trail == 0) { - unpack_bin(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + trail_ = load(n); + if(trail_ == 0) { + unpack_bin(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else { @@ -536,45 +534,45 @@ public: } break; case ACS_STR_VALUE: { - unpack_str(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + unpack_str(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case ACS_BIN_VALUE: { - unpack_bin(user_, data, n, trail, obj); - int ret = push_proc(c, obj, p, data, off, trail); + unpack_bin(user_, data, n, trail_, obj); + int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_ARRAY_16: { int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, c, obj, p, n, data, off, trail); + unpack_array(), CT_ARRAY_ITEM, obj, n, off); if (ret != 0) return ret; } break; case CS_ARRAY_32: { /* FIXME security guard */ int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, c, obj, p, n, data, off, trail); + unpack_array(), CT_ARRAY_ITEM, obj, n, off); if (ret != 0) return ret; } break; case CS_MAP_16: { int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, c, obj, p, n, data, off, trail); + unpack_map(), CT_MAP_KEY, obj, n, off); if (ret != 0) return ret; } break; case CS_MAP_32: { /* FIXME security guard */ int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, c, obj, p, n, data, off, trail); + unpack_map(), CT_MAP_KEY, obj, n, off); if (ret != 0) return ret; } break; default: - off = update_attributes(p, data, trail); + off = current_ - start_; return -1; } } - } while(p != pe); + } while(current_ != pe); - off = update_attributes(p, data, trail); + off = current_ - start_; return 0; } @@ -589,58 +587,44 @@ private: int push_aggregate( Func const& f, unsigned int ct, - unpack_stack*& c, object& obj, - const char*& current, const char* load_pos, - const char* origin, - size_t& off, - unsigned int trail) { + size_t& off) { if(top_ < MSGPACK_EMBED_STACK_SIZE /* FIXME */ && f(user_, load(load_pos), stack_[top_].obj())) { if(load(load_pos) == 0) { obj = stack_[top_].obj(); - int ret = push_proc(c, obj, current, origin, off, trail); + int ret = push_proc(obj, off); if (ret != 0) return ret; } else { stack_[top_].set_ct(ct); stack_[top_].set_count(load(load_pos)); ++top_; - header_again(current); + cs_ = CS_HEADER; + ++current_; } } else { - off = update_attributes(current, origin, trail); + off = current_ - start_; return -1; } return 0; } - size_t update_attributes( - const char* current, - const char* origin, - unsigned int trail) { - trail_ = trail; - return current - origin; - } - - void header_again(const char*& current) { - cs_ = CS_HEADER; - ++current; - } - int push_item(unpack_stack*& c, object& obj) { + int push_item(object& obj) { bool finish = false; while (!finish) { if(top_ == 0) { return 1; } - c = &stack_[top_ - 1]; - switch(c->ct()) { + stack_idx_ = top_ - 1; + unpack_stack* sp = &stack_[stack_idx_]; + switch(sp->ct()) { case CT_ARRAY_ITEM: - unpack_array_item(user_, c->obj(), obj); - if(c->decl_count() == 0) { - obj = c->obj(); + unpack_array_item(user_, sp->obj(), obj); + if(sp->decl_count() == 0) { + obj = sp->obj(); --top_; /*printf("stack pop %d\n", top_);*/ } @@ -649,19 +633,19 @@ private: } break; case CT_MAP_KEY: - c->set_map_key(obj); - c->set_ct(CT_MAP_VALUE); + sp->set_map_key(obj); + sp->set_ct(CT_MAP_VALUE); finish = true; break; case CT_MAP_VALUE: - unpack_map_item(user_, c->obj(), c->map_key(), obj); - if(c->decl_count() == 0) { - obj = c->obj(); + unpack_map_item(user_, sp->obj(), sp->map_key(), obj); + if(sp->decl_count() == 0) { + obj = sp->obj(); --top_; /*printf("stack pop %d\n", top_);*/ } else { - c->set_ct(CT_MAP_KEY); + sp->set_ct(CT_MAP_KEY); finish = true; } break; @@ -672,34 +656,34 @@ private: return 0; } - int push_proc( - unpack_stack*& c, - object& obj, - const char*& current, - const char* origin, - size_t& off, - unsigned int trail) { - int ret = push_item(c, obj); + int push_proc(object& obj, size_t& off) { + int ret = push_item(obj); if (ret > 0) { stack_[0].set_obj(obj); - ++current; + ++current_; /*printf("-- finish --\n"); */ - off = update_attributes(current, origin, trail); + off = current_ - start_; } else if (ret < 0) { - off = update_attributes(current, origin, trail); + off = current_ - start_; } else { - header_again(current); + cs_ = CS_HEADER; + ++current_; } return ret; } private: + size_t off_; + char const* start_; + char const* current_; + unsigned int trail_; unpack_user user_; unsigned int cs_; unsigned int top_; + unsigned int stack_idx_; unpack_stack stack_[MSGPACK_EMBED_STACK_SIZE]; }; From 378f6afccddc03a1044370cbe28875ca055feaeb Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 26 Mar 2014 16:40:32 +0900 Subject: [PATCH 066/153] Mapped std::stirng to STR instead of BIN for benchmark. --- src/msgpack/type/string.hpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index d072d861..62161f44 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -43,25 +43,25 @@ inline std::string& operator>> (object const& o, std::string& v) template inline packer& operator<< (packer& o, const std::string& v) { - o.pack_bin(v.size()); - o.pack_bin_body(v.data(), v.size()); + o.pack_str(v.size()); + o.pack_str_body(v.data(), v.size()); return o; } inline void operator<< (object::with_zone& o, const std::string& v) { - o.type = type::BIN; + o.type = type::STR; char* ptr = (char*)o.zone->allocate_align(v.size()); - o.via.bin.ptr = ptr; - o.via.bin.size = (uint32_t)v.size(); + o.via.str.ptr = ptr; + o.via.str.size = (uint32_t)v.size(); memcpy(ptr, v.data(), v.size()); } inline void operator<< (object& o, const std::string& v) { - o.type = type::BIN; - o.via.bin.ptr = v.data(); - o.via.bin.size = (uint32_t)v.size(); + o.type = type::STR; + o.via.str.ptr = v.data(); + o.via.str.size = (uint32_t)v.size(); } From 124a871923f45f937ab75ad57265b97b5ddb9746 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 31 Mar 2014 10:25:57 +0900 Subject: [PATCH 067/153] Removed redundant parameter. --- src/msgpack/unpack.hpp | 64 +++++++++++++++++++++--------------------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index a42bffcd..5575cbc3 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -62,47 +62,47 @@ private: bool referenced_; }; -inline void unpack_uint8(unpack_user&, uint8_t d, object& o) +inline void unpack_uint8(uint8_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void unpack_uint16(unpack_user&, uint16_t d, object& o) +inline void unpack_uint16(uint16_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void unpack_uint32(unpack_user&, uint32_t d, object& o) +inline void unpack_uint32(uint32_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void unpack_uint64(unpack_user&, uint64_t d, object& o) +inline void unpack_uint64(uint64_t d, object& o) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } -inline void unpack_int8(unpack_user&, int8_t d, object& o) +inline void unpack_int8(int8_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void unpack_int16(unpack_user&, int16_t d, object& o) +inline void unpack_int16(int16_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void unpack_int32(unpack_user&, int32_t d, object& o) +inline void unpack_int32(int32_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void unpack_int64(unpack_user&, int64_t d, object& o) +inline void unpack_int64(int64_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } -inline void unpack_float(unpack_user&, float d, object& o) +inline void unpack_float(float d, object& o) { o.type = type::DOUBLE; o.via.dec = d; } -inline void unpack_double(unpack_user&, double d, object& o) +inline void unpack_double(double d, object& o) { o.type = type::DOUBLE; o.via.dec = d; } -inline void unpack_nil(unpack_user&, object& o) +inline void unpack_nil(object& o) { o.type = type::NIL; } -inline void unpack_true(unpack_user&, object& o) +inline void unpack_true(object& o) { o.type = type::BOOLEAN; o.via.boolean = true; } -inline void unpack_false(unpack_user&, object& o) +inline void unpack_false(object& o) { o.type = type::BOOLEAN; o.via.boolean = false; } struct unpack_array { @@ -115,7 +115,7 @@ struct unpack_array { } }; -inline void unpack_array_item(unpack_user&, object& c, object const& o) +inline void unpack_array_item(object& c, object const& o) { c.via.array.ptr[c.via.array.size++] = o; } struct unpack_map { @@ -128,7 +128,7 @@ struct unpack_map { } }; -inline void unpack_map_item(unpack_user&, object& c, object const& k, object const& v) +inline void unpack_map_item(object& c, object const& k, object const& v) { c.via.map.ptr[c.via.map.size].key = k; c.via.map.ptr[c.via.map.size].val = v; @@ -291,28 +291,28 @@ public: int selector = *reinterpret_cast(current_); if (0) { } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum - unpack_uint8(user_, *reinterpret_cast(current_), obj); + unpack_uint8(*reinterpret_cast(current_), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum - unpack_int8(user_, *reinterpret_cast(current_), obj); + unpack_int8(*reinterpret_cast(current_), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else if(0xc0 <= selector && selector <= 0xdf) { // Variable switch(selector) { case 0xc0: { // nil - unpack_nil(user_, obj); + unpack_nil(obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; //case 0xc1: // string case 0xc2: { // false - unpack_false(user_, obj); + unpack_false(obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case 0xc3: { // true - unpack_true(user_, obj); + unpack_true(obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; @@ -406,7 +406,7 @@ public: case CS_FLOAT: { union { uint32_t i; float f; } mem; mem.i = load(n); - unpack_float(user_, mem.f, obj); + unpack_float(mem.f, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; @@ -417,47 +417,47 @@ public: // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - unpack_double(user_, mem.f, obj); + unpack_double(mem.f, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_8: { - unpack_uint8(user_, load(n), obj); + unpack_uint8(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_16: { - unpack_uint16(user_, load(n), obj); + unpack_uint16(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_32: { - unpack_uint32(user_, load(n), obj); + unpack_uint32(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_64: { - unpack_uint64(user_, load(n), obj); + unpack_uint64(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_8: { - unpack_int8(user_, load(n), obj); + unpack_int8(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_16: { - unpack_int16(user_, load(n), obj); + unpack_int16(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_32: { - unpack_int32(user_, load(n), obj); + unpack_int32(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_64: { - unpack_int64(user_, load(n), obj); + unpack_int64(load(n), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; @@ -622,7 +622,7 @@ private: unpack_stack* sp = &stack_[stack_idx_]; switch(sp->ct()) { case CT_ARRAY_ITEM: - unpack_array_item(user_, sp->obj(), obj); + unpack_array_item(sp->obj(), obj); if(sp->decl_count() == 0) { obj = sp->obj(); --top_; @@ -638,7 +638,7 @@ private: finish = true; break; case CT_MAP_VALUE: - unpack_map_item(user_, sp->obj(), sp->map_key(), obj); + unpack_map_item(sp->obj(), sp->map_key(), obj); if(sp->decl_count() == 0) { obj = sp->obj(); --top_; From ba98315f65e5d375eb316f4e7b1afc79a1923765 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 31 Mar 2014 10:34:26 +0900 Subject: [PATCH 068/153] The same fix as follows on C++ code. https://github.com/msgpack/msgpack-c/pull/38 --- src/msgpack/unpack.hpp | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 5575cbc3..8b6fe04b 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -116,7 +116,13 @@ struct unpack_array { }; inline void unpack_array_item(object& c, object const& o) -{ c.via.array.ptr[c.via.array.size++] = o; } +{ +#if defined(__GNUC__) && !defined(__clang__) + memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object)); +#else /* __GNUC__ && !__clang__ */ + c.via.array.ptr[c.via.array.size++] = o; +#endif /* __GNUC__ && !__clang__ */ +} struct unpack_map { bool operator()(unpack_user& u, unsigned int n, object& o) const { @@ -130,8 +136,13 @@ struct unpack_map { inline void unpack_map_item(object& c, object const& k, object const& v) { +#if defined(__GNUC__) && !defined(__clang__) + memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object)); + memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(object)); +#else /* __GNUC__ && !__clang__ */ c.via.map.ptr[c.via.map.size].key = k; c.via.map.ptr[c.via.map.size].val = v; +#endif /* __GNUC__ && !__clang__ */ ++c.via.map.size; } @@ -675,7 +686,6 @@ private: } private: - size_t off_; char const* start_; char const* current_; From 862905742f91d29452c6117e1ded2ac1dda8b281 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 31 Mar 2014 10:51:01 +0900 Subject: [PATCH 069/153] Renamed z with zone. --- src/msgpack/unpack.hpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 8b6fe04b..d2e60ac7 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -52,13 +52,13 @@ namespace detail { class unpack_user { public: - zone const& z() const { return *z_; } - zone& z() { return *z_; } - void set_z(zone& z) { z_ = &z; } + msgpack::zone const& zone() const { return *zone_; } + msgpack::zone& zone() { return *zone_; } + void set_zone(msgpack::zone& zone) { zone_ = &zone; } bool referenced() const { return referenced_; } void set_referenced(bool referenced) { referenced_ = referenced; } private: - zone* z_; + msgpack::zone* zone_; bool referenced_; }; @@ -109,7 +109,7 @@ struct unpack_array { bool operator()(unpack_user&u, unsigned int n, object& o) const { o.type = type::ARRAY; o.via.array.size = 0; - o.via.array.ptr = (object*)u.z().allocate_align(n*sizeof(object)); + o.via.array.ptr = (object*)u.zone().allocate_align(n*sizeof(object)); if(o.via.array.ptr == nullptr) { return false; } return true; } @@ -128,7 +128,7 @@ struct unpack_map { bool operator()(unpack_user& u, unsigned int n, object& o) const { o.type = type::MAP; o.via.map.size = 0; - o.via.map.ptr = (object_kv*)u.z().allocate_align(n*sizeof(object_kv)); + o.via.map.ptr = (object_kv*)u.zone().allocate_align(n*sizeof(object_kv)); if(o.via.map.ptr == nullptr) { return false; } return true; } @@ -894,7 +894,7 @@ inline unpacker::unpacker(size_t initial_buffer_size) detail::init_count(buffer_); ctx_.init(); - ctx_.user().set_z(*z_); + ctx_.user().set_zone(*z_); ctx_.user().set_referenced(false); } @@ -1051,7 +1051,7 @@ inline zone* unpacker::release_zone() zone* old = z_; z_ = r; - ctx_.user().set_z(*z_); + ctx_.user().set_zone(*z_); return old; } @@ -1131,7 +1131,7 @@ unpack_imp(const char* data, size_t len, size_t* off, detail::context ctx; ctx.init(); - ctx.user().set_z(result_zone); + ctx.user().set_zone(result_zone); ctx.user().set_referenced(false); int e = ctx.execute(data, len, noff); From cb9eed8ccc63a75faeec8b2dd370bca614696408 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 31 Mar 2014 10:56:36 +0900 Subject: [PATCH 070/153] Renamed from ct to container_type. --- src/msgpack/unpack.hpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index d2e60ac7..97e9db73 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -171,14 +171,14 @@ public: size_t count() const { return count_; } void set_count(size_t count) { count_ = count; } size_t decl_count() { return --count_; } - unsigned int ct() const { return ct_; } - void set_ct(unsigned int ct) { ct_ = ct; } + unsigned int container_type() const { return container_type_; } + void set_container_type(unsigned int container_type) { container_type_ = container_type; } object const& map_key() const { return map_key_; } void set_map_key(object const& map_key) { map_key_ = map_key; } private: object obj_; size_t count_; - unsigned int ct_; + unsigned int container_type_; object map_key_; }; @@ -597,7 +597,7 @@ private: template int push_aggregate( Func const& f, - unsigned int ct, + unsigned int container_type, object& obj, const char* load_pos, size_t& off) { @@ -609,7 +609,7 @@ private: if (ret != 0) return ret; } else { - stack_[top_].set_ct(ct); + stack_[top_].set_container_type(container_type); stack_[top_].set_count(load(load_pos)); ++top_; cs_ = CS_HEADER; @@ -631,7 +631,7 @@ private: } stack_idx_ = top_ - 1; unpack_stack* sp = &stack_[stack_idx_]; - switch(sp->ct()) { + switch(sp->container_type()) { case CT_ARRAY_ITEM: unpack_array_item(sp->obj(), obj); if(sp->decl_count() == 0) { @@ -645,7 +645,7 @@ private: break; case CT_MAP_KEY: sp->set_map_key(obj); - sp->set_ct(CT_MAP_VALUE); + sp->set_container_type(CT_MAP_VALUE); finish = true; break; case CT_MAP_VALUE: @@ -656,7 +656,7 @@ private: /*printf("stack pop %d\n", top_);*/ } else { - sp->set_ct(CT_MAP_KEY); + sp->set_container_type(CT_MAP_KEY); finish = true; } break; From 754b1682a55b4a44940fc31a354ea1eab4fbcb73 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 31 Mar 2014 12:44:25 +0900 Subject: [PATCH 071/153] Replaced C-style casts with C++ style casts. --- src/msgpack/object.hpp | 2 +- src/msgpack/pack.hpp | 52 ++++++++++++++++++------------------- src/msgpack/type/float.hpp | 12 ++++----- src/msgpack/type/int.hpp | 12 ++++----- src/msgpack/type/string.hpp | 6 ++--- src/msgpack/unpack.hpp | 20 +++++++------- src/msgpack/vrefbuffer.hpp | 2 +- src/msgpack/zbuffer.hpp | 2 +- 8 files changed, 53 insertions(+), 55 deletions(-) diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp index a622c100..a5d5bb80 100644 --- a/src/msgpack/object.hpp +++ b/src/msgpack/object.hpp @@ -530,7 +530,7 @@ std::ostream& operator<< (std::ostream& s, const object& o) default: // FIXME - s << "#"; + s << "#(o.type) << ">"; } return s; } diff --git a/src/msgpack/pack.hpp b/src/msgpack/pack.hpp index 7010d4e3..2e247719 100644 --- a/src/msgpack/pack.hpp +++ b/src/msgpack/pack.hpp @@ -616,11 +616,11 @@ inline packer& packer::pack_array(size_t n) append_buffer(&d, 1); } else if(n < 65536) { char buf[3]; - buf[0] = static_cast(0xdc); _msgpack_store16(&buf[1], (uint16_t)n); + buf[0] = static_cast(0xdc); _msgpack_store16(&buf[1], static_cast(n)); append_buffer(buf, 3); } else { char buf[5]; - buf[0] = static_cast(0xdd); _msgpack_store32(&buf[1], (uint32_t)n); + buf[0] = static_cast(0xdd); _msgpack_store32(&buf[1], static_cast(n)); append_buffer(buf, 5); } return *this; @@ -635,11 +635,11 @@ inline packer& packer::pack_map(size_t n) append_buffer(&buf, 1); } else if(n < 65536) { char buf[3]; - buf[0] = static_cast(0xde); _msgpack_store16(&buf[1], (uint16_t)n); + buf[0] = static_cast(0xde); _msgpack_store16(&buf[1], static_cast(n)); append_buffer(buf, 3); } else { char buf[5]; - buf[0] = static_cast(0xdf); _msgpack_store32(&buf[1], (uint32_t)n); + buf[0] = static_cast(0xdf); _msgpack_store32(&buf[1], static_cast(n)); append_buffer(buf, 5); } return *this; @@ -649,20 +649,20 @@ template inline packer& packer::pack_str(size_t l) { if(l < 32) { - unsigned char d = 0xa0 | (uint8_t)l; + unsigned char d = 0xa0 | static_cast(l); char buf = take8_8(d); append_buffer(&buf, 1); } else if(l < 256) { char buf[2]; - buf[0] = static_cast(0xd9); buf[1] = (uint8_t)l; + buf[0] = static_cast(0xd9); buf[1] = static_cast(l); append_buffer(buf, 2); } else if(l < 65536) { char buf[3]; - buf[0] = static_cast(0xda); _msgpack_store16(&buf[1], (uint16_t)l); + buf[0] = static_cast(0xda); _msgpack_store16(&buf[1], static_cast(l)); append_buffer(buf, 3); } else { char buf[5]; - buf[0] = static_cast(0xdb); _msgpack_store32(&buf[1], (uint32_t)l); + buf[0] = static_cast(0xdb); _msgpack_store32(&buf[1], static_cast(l)); append_buffer(buf, 5); } return *this; @@ -680,15 +680,15 @@ inline packer& packer::pack_bin(size_t l) { if(l < 256) { char buf[2]; - buf[0] = static_cast(0xc4); buf[1] = (uint8_t)l; + buf[0] = static_cast(0xc4); buf[1] = static_cast(l); append_buffer(buf, 2); } else if(l < 65536) { char buf[3]; - buf[0] = static_cast(0xc5); _msgpack_store16(&buf[1], (uint16_t)l); + buf[0] = static_cast(0xc5); _msgpack_store16(&buf[1], static_cast(l)); append_buffer(buf, 3); } else { char buf[5]; - buf[0] = static_cast(0xc6); _msgpack_store32(&buf[1], (uint32_t)l); + buf[0] = static_cast(0xc6); _msgpack_store32(&buf[1], static_cast(l)); append_buffer(buf, 5); } return *this; @@ -731,7 +731,7 @@ inline void packer::pack_imp_uint16(T d) } else { /* unsigned 16 */ char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } } @@ -754,12 +754,12 @@ inline void packer::pack_imp_uint32(T d) if(d < (1<<16)) { /* unsigned 16 */ char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } else { /* unsigned 32 */ char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); append_buffer(buf, 5); } } @@ -783,12 +783,12 @@ inline void packer::pack_imp_uint64(T d) if(d < (1ULL<<16)) { /* unsigned 16 */ char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } else if(d < (1ULL<<32)) { /* unsigned 32 */ char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); append_buffer(buf, 5); } else { /* unsigned 64 */ @@ -822,7 +822,7 @@ inline void packer::pack_imp_int16(T d) if(d < -(1<<7)) { /* signed 16 */ char buf[3]; - buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], (int16_t)d); + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } else { /* signed 8 */ @@ -841,7 +841,7 @@ inline void packer::pack_imp_int16(T d) } else { /* unsigned 16 */ char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } } @@ -855,12 +855,12 @@ inline void packer::pack_imp_int32(T d) if(d < -(1<<15)) { /* signed 32 */ char buf[5]; - buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], (int32_t)d); + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); append_buffer(buf, 5); } else if(d < -(1<<7)) { /* signed 16 */ char buf[3]; - buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], (int16_t)d); + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } else { /* signed 8 */ @@ -879,12 +879,12 @@ inline void packer::pack_imp_int32(T d) } else if(d < (1<<16)) { /* unsigned 16 */ char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } else { /* unsigned 32 */ char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); append_buffer(buf, 5); } } @@ -904,14 +904,14 @@ inline void packer::pack_imp_int64(T d) } else { /* signed 32 */ char buf[5]; - buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], (int32_t)d); + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); append_buffer(buf, 5); } } else { if(d < -(1<<7)) { /* signed 16 */ char buf[3]; - buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], (int16_t)d); + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } else { /* signed 8 */ @@ -932,14 +932,14 @@ inline void packer::pack_imp_int64(T d) } else { /* unsigned 16 */ char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], (uint16_t)d); + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); append_buffer(buf, 3); } } else { if(d < (1LL<<32)) { /* unsigned 32 */ char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], (uint32_t)d); + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); append_buffer(buf, 5); } else { /* unsigned 64 */ diff --git a/src/msgpack/type/float.hpp b/src/msgpack/type/float.hpp index fbbe8aed..48bc1be8 100644 --- a/src/msgpack/type/float.hpp +++ b/src/msgpack/type/float.hpp @@ -30,13 +30,13 @@ namespace msgpack { inline float& operator>> (object const& o, float& v) { if(o.type == type::DOUBLE) { - v = (float)o.via.dec; + v = static_cast(o.via.dec); } else if (o.type == type::POSITIVE_INTEGER) { - v = (float)o.via.u64; + v = static_cast(o.via.u64); } else if (o.type == type::NEGATIVE_INTEGER) { - v = (float)o.via.i64; + v = static_cast(o.via.i64); } else { throw type_error(); @@ -58,10 +58,10 @@ inline double& operator>> (object const& o, double& v) v = o.via.dec; } else if (o.type == type::POSITIVE_INTEGER) { - v = (double)o.via.u64; + v = static_cast(o.via.u64); } else if (o.type == type::NEGATIVE_INTEGER) { - v = (double)o.via.i64; + v = static_cast(o.via.i64); } else { throw type_error(); @@ -80,7 +80,7 @@ inline packer& operator<< (packer& o, const double& v) inline void operator<< (object& o, float v) { o.type = type::DOUBLE; - o.via.dec = (double)v; + o.via.dec = static_cast(v); } inline void operator<< (object& o, double v) diff --git a/src/msgpack/type/int.hpp b/src/msgpack/type/int.hpp index e70e2043..f1b588b6 100644 --- a/src/msgpack/type/int.hpp +++ b/src/msgpack/type/int.hpp @@ -33,13 +33,13 @@ namespace detail { struct convert_integer_sign { static inline T convert(object const& o) { if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > (uint64_t)std::numeric_limits::max()) + if(o.via.u64 > static_cast(std::numeric_limits::max())) { throw type_error(); } - return (T)o.via.u64; + return static_cast(o.via.u64); } else if(o.type == type::NEGATIVE_INTEGER) { - if(o.via.i64 < (int64_t)std::numeric_limits::min()) + if(o.via.i64 < static_cast(std::numeric_limits::min())) { throw type_error(); } - return (T)o.via.i64; + return static_cast(o.via.i64); } throw type_error(); } @@ -49,9 +49,9 @@ namespace detail { struct convert_integer_sign { static inline T convert(object const& o) { if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > (uint64_t)std::numeric_limits::max()) + if(o.via.u64 > static_cast(std::numeric_limits::max())) { throw type_error(); } - return (T)o.via.u64; + return static_cast(o.via.u64); } throw type_error(); } diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp index 62161f44..5f99fe58 100644 --- a/src/msgpack/type/string.hpp +++ b/src/msgpack/type/string.hpp @@ -51,9 +51,9 @@ inline packer& operator<< (packer& o, const std::string& v) inline void operator<< (object::with_zone& o, const std::string& v) { o.type = type::STR; - char* ptr = (char*)o.zone->allocate_align(v.size()); + char* ptr = static_cast(o.zone->allocate_align(v.size())); o.via.str.ptr = ptr; - o.via.str.size = (uint32_t)v.size(); + o.via.str.size = static_cast(v.size()); memcpy(ptr, v.data(), v.size()); } @@ -61,7 +61,7 @@ inline void operator<< (object& o, const std::string& v) { o.type = type::STR; o.via.str.ptr = v.data(); - o.via.str.size = (uint32_t)v.size(); + o.via.str.size = static_cast(v.size()); } diff --git a/src/msgpack/unpack.hpp b/src/msgpack/unpack.hpp index 97e9db73..a82d2238 100644 --- a/src/msgpack/unpack.hpp +++ b/src/msgpack/unpack.hpp @@ -109,7 +109,7 @@ struct unpack_array { bool operator()(unpack_user&u, unsigned int n, object& o) const { o.type = type::ARRAY; o.via.array.size = 0; - o.via.array.ptr = (object*)u.zone().allocate_align(n*sizeof(object)); + o.via.array.ptr = static_cast(u.zone().allocate_align(n*sizeof(object))); if(o.via.array.ptr == nullptr) { return false; } return true; } @@ -128,7 +128,7 @@ struct unpack_map { bool operator()(unpack_user& u, unsigned int n, object& o) const { o.type = type::MAP; o.via.map.size = 0; - o.via.map.ptr = (object_kv*)u.zone().allocate_align(n*sizeof(object_kv)); + o.via.map.ptr = static_cast(u.zone().allocate_align(n*sizeof(object_kv))); if(o.via.map.ptr == nullptr) { return false; } return true; } @@ -184,26 +184,24 @@ private: inline void init_count(void* buffer) { - *(volatile _msgpack_atomic_counter_t*)buffer = 1; + *reinterpret_cast(buffer) = 1; } inline void decl_count(void* buffer) { - // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); } - if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) { + if(_msgpack_sync_decr_and_fetch(reinterpret_cast(buffer)) == 0) { free(buffer); } } inline void incr_count(void* buffer) { - // atomic ++*(_msgpack_atomic_counter_t*)buffer; - _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer); + _msgpack_sync_incr_and_fetch(reinterpret_cast(buffer)); } inline _msgpack_atomic_counter_t get_count(void* buffer) { - return *(volatile _msgpack_atomic_counter_t*)buffer; + return *reinterpret_cast(buffer); } struct fix_tag { @@ -872,7 +870,7 @@ inline unpacker::unpacker(size_t initial_buffer_size) initial_buffer_size = COUNTER_SIZE; } - char* buffer = reinterpret_cast(::malloc(initial_buffer_size)); + char* buffer = static_cast(::malloc(initial_buffer_size)); if(!buffer) { throw std::bad_alloc(); } @@ -929,7 +927,7 @@ inline void unpacker::expand_buffer(size_t size) next_size *= 2; } - char* tmp = reinterpret_cast(::realloc(buffer_, next_size)); + char* tmp = static_cast(::realloc(buffer_, next_size)); if(!tmp) { throw std::bad_alloc(); } @@ -944,7 +942,7 @@ inline void unpacker::expand_buffer(size_t size) next_size *= 2; } - char* tmp = reinterpret_cast(::malloc(next_size)); + char* tmp = static_cast(::malloc(next_size)); if(!tmp) { throw std::bad_alloc(); } diff --git a/src/msgpack/vrefbuffer.hpp b/src/msgpack/vrefbuffer.hpp index a2f4db58..97afcf38 100644 --- a/src/msgpack/vrefbuffer.hpp +++ b/src/msgpack/vrefbuffer.hpp @@ -128,7 +128,7 @@ public: tail_ = nvec + nused; } - tail_->iov_base = (char*)buf; + tail_->iov_base = const_cast(buf); tail_->iov_len = len; ++tail_; } diff --git a/src/msgpack/zbuffer.hpp b/src/msgpack/zbuffer.hpp index 117bc498..da84edae 100644 --- a/src/msgpack/zbuffer.hpp +++ b/src/msgpack/zbuffer.hpp @@ -102,7 +102,7 @@ public: size_t size() const { - return (char*)stream_.next_out - data_; + return reinterpret_cast(stream_.next_out) - data_; } void reset() From bc33317b7e519b1ae6c5e7b79f2b5ab396b6f23a Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 4 Jun 2014 16:56:43 +0900 Subject: [PATCH 072/153] Reorganized tree. --- CMakeLists.txt | 126 +- README.md | 26 +- configure.in | 29 +- .../cpp03_define.hpp.erb | 6 +- .../cpp03_msgpack_tuple.hpp.erb | 7 +- .../zone.hpp.erb => erb/cpp03_zone.hpp.erb | 8 +- {src => include}/msgpack.h | 0 {src => include}/msgpack.hpp | 0 .../type => include/msgpack/adaptor}/bool.hpp | 0 include/msgpack/adaptor/define.hpp | 29 + .../msgpack/adaptor}/deque.hpp | 0 .../msgpack/adaptor/detail/cpp03_define.hpp | 1198 ++++++------- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 1488 ++++++++++------- .../msgpack/adaptor/detail/cpp11_define.hpp | 10 +- .../adaptor/detail/cpp11_msgpack_tuple.hpp | 6 +- .../msgpack/adaptor}/fixint.hpp | 2 +- .../msgpack/adaptor}/float.hpp | 0 .../type => include/msgpack/adaptor}/int.hpp | 0 .../type => include/msgpack/adaptor}/list.hpp | 0 .../type => include/msgpack/adaptor}/map.hpp | 0 include/msgpack/adaptor/msgpack_tuple.hpp | 29 + .../type => include/msgpack/adaptor}/nil.hpp | 0 .../type => include/msgpack/adaptor}/pair.hpp | 0 .../type => include/msgpack/adaptor}/raw.hpp | 0 .../type => include/msgpack/adaptor}/set.hpp | 0 .../msgpack/adaptor}/string.hpp | 0 .../msgpack/adaptor}/tr1/unordered_map.hpp | 0 .../msgpack/adaptor}/tr1/unordered_set.hpp | 0 .../msgpack/adaptor}/vector.hpp | 0 {src => include}/msgpack/cpp_config.hpp | 13 + .../msgpack/detail/cpp03_zone.hpp | 492 ++++-- .../msgpack/detail/cpp11_zone.hpp | 8 +- {src => include}/msgpack/fbuffer.h | 0 {src => include}/msgpack/fbuffer.hpp | 0 {src => include/msgpack}/gcc_atomic.h | 0 {src => include}/msgpack/object.h | 0 {src => include}/msgpack/object.hpp | 0 {src => include}/msgpack/pack.h | 0 {src => include}/msgpack/pack.hpp | 0 {src => include}/msgpack/pack_define.h | 0 {src => include}/msgpack/pack_template.h | 0 {src => include}/msgpack/sbuffer.h | 0 {src => include}/msgpack/sbuffer.hpp | 0 {src => include}/msgpack/sysdep.h | 0 include/msgpack/type.hpp | 17 + {src => include}/msgpack/unpack.h | 0 {src => include}/msgpack/unpack.hpp | 0 {src => include}/msgpack/unpack_define.h | 0 {src => include}/msgpack/unpack_template.h | 0 .../version.h.in => include/msgpack/version.h | 8 +- .../msgpack/version.hpp | 9 +- include/msgpack/version_master.h | 3 + {src => include}/msgpack/vrefbuffer.h | 0 {src => include}/msgpack/vrefbuffer.hpp | 0 {src => include}/msgpack/zbuffer.h | 0 {src => include}/msgpack/zbuffer.hpp | 0 {src => include}/msgpack/zone.h | 0 include/msgpack/zone.hpp | 29 + preprocess | 8 +- preprocess_cpp11 | 17 - src/Makefile.am | 100 +- src/gcc_atomic.hpp | 2 +- src/msgpack/type.hpp | 17 - test/Makefile.am | 4 +- test/msgpack_test.cpp | 8 +- 65 files changed, 2081 insertions(+), 1618 deletions(-) rename src/msgpack/type/define.hpp.erb => erb/cpp03_define.hpp.erb (97%) rename src/msgpack/type/tuple.hpp.erb => erb/cpp03_msgpack_tuple.hpp.erb (98%) rename src/msgpack/zone.hpp.erb => erb/cpp03_zone.hpp.erb (98%) rename {src => include}/msgpack.h (100%) rename {src => include}/msgpack.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/bool.hpp (100%) create mode 100644 include/msgpack/adaptor/define.hpp rename {src/msgpack/type => include/msgpack/adaptor}/deque.hpp (100%) rename src/msgpack/type/define.hpp => include/msgpack/adaptor/detail/cpp03_define.hpp (82%) rename src/msgpack/type/tuple.hpp => include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp (95%) rename cpp11/define.hpp => include/msgpack/adaptor/detail/cpp11_define.hpp (96%) rename cpp11/tuple.hpp => include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp (97%) rename {src/msgpack/type => include/msgpack/adaptor}/fixint.hpp (99%) rename {src/msgpack/type => include/msgpack/adaptor}/float.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/int.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/list.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/map.hpp (100%) create mode 100644 include/msgpack/adaptor/msgpack_tuple.hpp rename {src/msgpack/type => include/msgpack/adaptor}/nil.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/pair.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/raw.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/set.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/string.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/tr1/unordered_map.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/tr1/unordered_set.hpp (100%) rename {src/msgpack/type => include/msgpack/adaptor}/vector.hpp (100%) rename {src => include}/msgpack/cpp_config.hpp (86%) rename src/msgpack/zone.hpp => include/msgpack/detail/cpp03_zone.hpp (51%) rename cpp11/zone.hpp => include/msgpack/detail/cpp11_zone.hpp (97%) rename {src => include}/msgpack/fbuffer.h (100%) rename {src => include}/msgpack/fbuffer.hpp (100%) rename {src => include/msgpack}/gcc_atomic.h (100%) rename {src => include}/msgpack/object.h (100%) rename {src => include}/msgpack/object.hpp (100%) rename {src => include}/msgpack/pack.h (100%) rename {src => include}/msgpack/pack.hpp (100%) rename {src => include}/msgpack/pack_define.h (100%) rename {src => include}/msgpack/pack_template.h (100%) rename {src => include}/msgpack/sbuffer.h (100%) rename {src => include}/msgpack/sbuffer.hpp (100%) rename {src => include}/msgpack/sysdep.h (100%) create mode 100644 include/msgpack/type.hpp rename {src => include}/msgpack/unpack.h (100%) rename {src => include}/msgpack/unpack.hpp (100%) rename {src => include}/msgpack/unpack_define.h (100%) rename {src => include}/msgpack/unpack_template.h (100%) rename src/msgpack/version.h.in => include/msgpack/version.h (77%) rename src/msgpack/version.hpp.in => include/msgpack/version.hpp (79%) create mode 100644 include/msgpack/version_master.h rename {src => include}/msgpack/vrefbuffer.h (100%) rename {src => include}/msgpack/vrefbuffer.hpp (100%) rename {src => include}/msgpack/zbuffer.h (100%) rename {src => include}/msgpack/zbuffer.hpp (100%) rename {src => include}/msgpack/zone.h (100%) create mode 100644 include/msgpack/zone.hpp delete mode 100755 preprocess_cpp11 delete mode 100644 src/msgpack/type.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 391b490b..f9a1663e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,26 +29,6 @@ IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND) OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON) ENDIF () - -# Files to copy - -MACRO (COPY_FILE SOURCE DESTINATION) - # COPY_FILE (readme.txt dir1/dir2/) would add new target - # that will copy readme.txt to dir1/dir2 where dir1 will be located - # in current binary directory. - ADD_CUSTOM_COMMAND ( - OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${DESTINATION}/${SOURCE} - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${DESTINATION} - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE} ${CMAKE_CURRENT_BINARY_DIR}/${DESTINATION}/${SOURCE} - ) -ENDMACRO () - -IF (MSGPACK_CXX11) - COPY_FILE (cpp11/zone.hpp src/msgpack/zone.hpp) - COPY_FILE (cpp11/define.hpp src/msgpack/type/define.hpp) - COPY_FILE (cpp11/tuple.hpp src/msgpack/type/tuple.hpp) -ENDIF () - OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON) INCLUDE (CheckCXXSourceCompiles) @@ -79,51 +59,57 @@ LIST (APPEND msgpack_SOURCES ) LIST (APPEND msgpack_HEADERS - src/msgpack/pack_define.h - src/msgpack/pack_template.h - src/msgpack/unpack_define.h - src/msgpack/unpack_template.h - src/msgpack/sysdep.h - src/msgpack/sbuffer.h - src/msgpack/version.h - src/msgpack/vrefbuffer.h - src/msgpack/zbuffer.h - src/msgpack/fbuffer.h - src/msgpack/pack.h - src/msgpack/unpack.h - src/msgpack/object.h - src/msgpack/zone.h + include/msgpack/pack_define.h + include/msgpack/pack_template.h + include/msgpack/unpack_define.h + include/msgpack/unpack_template.h + include/msgpack/sysdep.h + include/msgpack/sbuffer.h + include/msgpack/version.h + include/msgpack/vrefbuffer.h + include/msgpack/zbuffer.h + include/msgpack/fbuffer.h + include/msgpack/pack.h + include/msgpack/unpack.h + include/msgpack/object.h + include/msgpack/zone.h ) IF (MSGPACK_ENABLE_CXX) LIST (APPEND msgpack_HEADERS - src/msgpack.hpp - src/msgpack/sbuffer.hpp - src/msgpack/vrefbuffer.hpp - src/msgpack/zbuffer.hpp - src/msgpack/fbuffer.hpp - src/msgpack/pack.hpp - src/msgpack/unpack.hpp - src/msgpack/object.hpp - src/msgpack/zone.hpp - src/msgpack/type.hpp - src/msgpack/type/bool.hpp - src/msgpack/type/deque.hpp - src/msgpack/type/float.hpp - src/msgpack/type/fixint.hpp - src/msgpack/type/int.hpp - src/msgpack/type/list.hpp - src/msgpack/type/map.hpp - src/msgpack/type/nil.hpp - src/msgpack/type/pair.hpp - src/msgpack/type/raw.hpp - src/msgpack/type/set.hpp - src/msgpack/type/string.hpp - src/msgpack/type/vector.hpp - src/msgpack/type/tuple.hpp - src/msgpack/type/define.hpp - src/msgpack/type/tr1/unordered_map.hpp - src/msgpack/type/tr1/unordered_set.hpp + include/msgpack.hpp + include/msgpack/sbuffer.hpp + include/msgpack/vrefbuffer.hpp + include/msgpack/zbuffer.hpp + include/msgpack/fbuffer.hpp + include/msgpack/pack.hpp + include/msgpack/unpack.hpp + include/msgpack/object.hpp + include/msgpack/zone.hpp + include/msgpack/detail/cpp03_zone.hpp + include/msgpack/detail/cpp11_zone.hpp + include/msgpack/type.hpp + include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/deque.hpp + include/msgpack/adaptor/float.hpp + include/msgpack/adaptor/fixint.hpp + include/msgpack/adaptor/int.hpp + include/msgpack/adaptor/list.hpp + include/msgpack/adaptor/map.hpp + include/msgpack/adaptor/nil.hpp + include/msgpack/adaptor/pair.hpp + include/msgpack/adaptor/raw.hpp + include/msgpack/adaptor/set.hpp + include/msgpack/adaptor/string.hpp + include/msgpack/adaptor/vector.hpp + include/msgpack/adaptor/msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp + include/msgpack/adaptor/define.hpp + include/msgpack/adaptor/detail/cpp03_define.hpp + include/msgpack/adaptor/detail/cpp11_define.hpp + include/msgpack/adaptor/tr1/unordered_map.hpp + include/msgpack/adaptor/tr1/unordered_set.hpp ) ENDIF () @@ -131,15 +117,6 @@ EXECUTE_PROCESS ( COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack ) -CONFIGURE_FILE ( - src/msgpack/version.h.in - ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.h -) -CONFIGURE_FILE ( - src/msgpack/version.hpp.in - ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/version.hpp -) - CONFIGURE_FILE ( msgpack.pc.in msgpack.pc @@ -148,10 +125,8 @@ CONFIGURE_FILE ( INCLUDE_DIRECTORIES ( ./ - src/ - src/msgpack/ - ${CMAKE_CURRENT_BINARY_DIR}/src/ - ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack/ + include/ + ${CMAKE_CURRENT_BINARY_DIR}/include/ ) ADD_LIBRARY (msgpack SHARED @@ -186,8 +161,7 @@ IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") ENDIF () INSTALL (TARGETS msgpack msgpack-static DESTINATION lib) -INSTALL (DIRECTORY src/msgpack DESTINATION include) -INSTALL (FILES src/msgpack.h src/msgpack.hpp DESTINATION include) +INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX}) INSTALL (FILES msgpack.pc DESTINATION lib/pkgconfig) # Doxygen diff --git a/README.md b/README.md index c512eb6d..08606756 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,15 @@ To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack ## Using Msgpack +### Header only library for C++ +When you use msgpack on C++03 and C++11, you just add msgpack-c/include to your include path. You don't need to link any msgpack libraries. + +e.g.) + +``` +g++ -I msgpack-c/include your_source_file.cpp +``` + ### Building and Installing #### Install from git repository @@ -29,11 +38,8 @@ To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack ##### Using autotools You will need gcc (4.1.0 or higher), autotools. -You can use msgpack-c as a header only library on C++11 and C++03. +For C++03 and C: -You don't need to prepare ruby when you choose C++11 configuration. - -For C++11: ``` $ git clone https://github.com/redboltz/msgpack-c/tree/cxx_separate $ cd msgpack-c @@ -43,14 +49,17 @@ $ make $ sudo make install ``` -If you want to setup C++11 version of msgpack, execute the following command: +For C++11: ``` $ git clone https://github.com/msgpack/msgpack-c.git $ cd msgpack-c $ ./bootstrap $ ./configure CXXFLAGS="-std=c++11" +$ make +$ sudo make install ``` + You need the compiler that fully supports C++11. ##### Using cmake @@ -120,12 +129,13 @@ Open the created msgpack.sln on Visual Studio. Build all. -### Linking with an Application +### Linking with an Application for C -Include `msgpack.hpp` (or `msgpack.h` for C) in your application and link with libmsgpack. Here is a typical gcc link command: +Include `msgpack.h` in your application and link with libmsgpack. Here is a typical gcc link command: - g++ myapp.cpp -lmsgpack -o myapp + gcc myapp.c -lmsgpack -o myapp +When you use the C++ version of the msgpack, you don't need to link any msgpack libraries. ### Code Example ```CPP diff --git a/configure.in b/configure.in index 68f47ef8..fdf53c2e 100644 --- a/configure.in +++ b/configure.in @@ -1,29 +1,11 @@ -AC_INIT([msgpack], [0.5.9]) +major=`sed -n 's/#define MSGPACK_VERSION_MAJOR\s\(.*\)/\1/p' include/msgpack/version_master.h` +minor=`sed -n 's/#define MSGPACK_VERSION_MINOR\s\(.*\)/\1/p' include/msgpack/version_master.h` +release=`sed -n 's/#define MSGPACK_VERSION_RELEASE\s\(.*\)/\1/p' include/msgpack/version_master.h` +AC_INIT(msgpack, $major.$minor.$release) AC_CONFIG_AUX_DIR(ac) AM_INIT_AUTOMAKE AC_CONFIG_HEADER(config.h) - -AC_LANG_PUSH([C++]) -AC_COMPILE_IFELSE([AC_LANG_SOURCE([ -#if __cplusplus < 201103 -#error -#endif -])], -[ -./preprocess_cpp11 -if test $? != 0; then - exit 1 -fi -], -[ -./preprocess -if test $? != 0; then - exit 1 -fi -]) -AC_LANG_POP() - AC_SUBST(CFLAGS) CFLAGS="-O3 -Wall $CFLAGS" @@ -115,7 +97,4 @@ AC_SUBST(VERSION_MINOR, $minor) AC_OUTPUT([Makefile msgpack.pc src/Makefile - src/msgpack/version.h - src/msgpack/version.hpp test/Makefile]) - diff --git a/src/msgpack/type/define.hpp.erb b/erb/cpp03_define.hpp.erb similarity index 97% rename from src/msgpack/type/define.hpp.erb rename to erb/cpp03_define.hpp.erb index fc233969..d5268f8e 100644 --- a/src/msgpack/type/define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_DEFINE_HPP -#define MSGPACK_TYPE_DEFINE_HPP +#ifndef MSGPACK_CPP03_DEFINE_HPP +#define MSGPACK_CPP03_DEFINE_HPP #define MSGPACK_DEFINE(...) \ template \ @@ -144,5 +144,5 @@ define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, } // namespace msgpack -#endif /* msgpack/type/define.hpp */ +#endif // MSGPACK_CPP03_DEFINE_HPP diff --git a/src/msgpack/type/tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb similarity index 98% rename from src/msgpack/type/tuple.hpp.erb rename to erb/cpp03_msgpack_tuple.hpp.erb index d5ff3e0c..da5716b6 100644 --- a/src/msgpack/type/tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_TUPLE_HPP -#define MSGPACK_TYPE_TUPLE_HPP +#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_HPP +#define MSGPACK_CPP03_MSGPACK_TUPLE_HPP #include "msgpack/object.hpp" @@ -208,5 +208,4 @@ inline void operator<< ( //} //<%}%> -#endif /* msgpack/type/tuple.hpp */ - +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP diff --git a/src/msgpack/zone.hpp.erb b/erb/cpp03_zone.hpp.erb similarity index 98% rename from src/msgpack/zone.hpp.erb rename to erb/cpp03_zone.hpp.erb index 28382b21..e2228c30 100644 --- a/src/msgpack/zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -15,14 +15,14 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_ZONE_HPP -#define MSGPACK_ZONE_HPP +#ifndef MSGPACK_CPP03_ZONE_HPP +#define MSGPACK_CPP03_ZONE_HPP #include #include #include -#include "cpp_config.hpp" +#include "msgpack/cpp_config.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 @@ -317,4 +317,4 @@ T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) } // namespace msgpack -#endif /* msgpack/zone.hpp */ +#endif // MSGPACK_CPP03_ZONE_HPP diff --git a/src/msgpack.h b/include/msgpack.h similarity index 100% rename from src/msgpack.h rename to include/msgpack.h diff --git a/src/msgpack.hpp b/include/msgpack.hpp similarity index 100% rename from src/msgpack.hpp rename to include/msgpack.hpp diff --git a/src/msgpack/type/bool.hpp b/include/msgpack/adaptor/bool.hpp similarity index 100% rename from src/msgpack/type/bool.hpp rename to include/msgpack/adaptor/bool.hpp diff --git a/include/msgpack/adaptor/define.hpp b/include/msgpack/adaptor/define.hpp new file mode 100644 index 00000000..bf0b6195 --- /dev/null +++ b/include/msgpack/adaptor/define.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_DEFINE_HPP +#define MSGPACK_DEFINE_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_define.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_define.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_DEFINE_HPP diff --git a/src/msgpack/type/deque.hpp b/include/msgpack/adaptor/deque.hpp similarity index 100% rename from src/msgpack/type/deque.hpp rename to include/msgpack/adaptor/deque.hpp diff --git a/src/msgpack/type/define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp similarity index 82% rename from src/msgpack/type/define.hpp rename to include/msgpack/adaptor/detail/cpp03_define.hpp index bb8e2137..38d3d8cb 100644 --- a/src/msgpack/type/define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_DEFINE_HPP__ -#define MSGPACK_TYPE_DEFINE_HPP__ +#ifndef MSGPACK_CPP03_DEFINE_HPP +#define MSGPACK_CPP03_DEFINE_HPP #define MSGPACK_DEFINE(...) \ template \ @@ -24,7 +24,7 @@ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ } \ - void msgpack_unpack(msgpack::object o) \ + void msgpack_unpack(msgpack::object const& o) \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ @@ -38,7 +38,7 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object o, enum& v) \ + inline enum& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ @@ -78,14 +78,14 @@ struct define<> { { pk.pack_array(0); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = NULL; + o->via.array.ptr = nullptr; o->via.array.size = 0; } }; @@ -103,7 +103,7 @@ struct define { pk.pack(a0); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -111,14 +111,14 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 1: ptr[0].convert(&a0); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*1); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*1)); o->via.array.size = 1; o->via.array.ptr[0] = object(a0, z); @@ -141,7 +141,7 @@ struct define { pk.pack(a0); pk.pack(a1); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -149,15 +149,15 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*2); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*2)); o->via.array.size = 2; o->via.array.ptr[0] = object(a0, z); @@ -183,7 +183,7 @@ struct define { pk.pack(a1); pk.pack(a2); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -191,16 +191,16 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*3); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*3)); o->via.array.size = 3; o->via.array.ptr[0] = object(a0, z); @@ -229,7 +229,7 @@ struct define { pk.pack(a2); pk.pack(a3); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -237,17 +237,17 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*4); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*4)); o->via.array.size = 4; o->via.array.ptr[0] = object(a0, z); @@ -279,7 +279,7 @@ struct define { pk.pack(a3); pk.pack(a4); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -287,18 +287,18 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*5); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*5)); o->via.array.size = 5; o->via.array.ptr[0] = object(a0, z); @@ -333,7 +333,7 @@ struct define { pk.pack(a4); pk.pack(a5); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -341,19 +341,19 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*6); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*6)); o->via.array.size = 6; o->via.array.ptr[0] = object(a0, z); @@ -391,7 +391,7 @@ struct define { pk.pack(a5); pk.pack(a6); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -399,20 +399,20 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*7); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*7)); o->via.array.size = 7; o->via.array.ptr[0] = object(a0, z); @@ -453,7 +453,7 @@ struct define { pk.pack(a6); pk.pack(a7); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -461,21 +461,21 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*8); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*8)); o->via.array.size = 8; o->via.array.ptr[0] = object(a0, z); @@ -519,7 +519,7 @@ struct define { pk.pack(a7); pk.pack(a8); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -527,22 +527,22 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*9); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*9)); o->via.array.size = 9; o->via.array.ptr[0] = object(a0, z); @@ -589,7 +589,7 @@ struct define { pk.pack(a8); pk.pack(a9); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -597,23 +597,23 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*10); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*10)); o->via.array.size = 10; o->via.array.ptr[0] = object(a0, z); @@ -663,7 +663,7 @@ struct define { pk.pack(a9); pk.pack(a10); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -671,24 +671,24 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*11); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*11)); o->via.array.size = 11; o->via.array.ptr[0] = object(a0, z); @@ -741,7 +741,7 @@ struct define { pk.pack(a10); pk.pack(a11); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -749,25 +749,25 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*12); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*12)); o->via.array.size = 12; o->via.array.ptr[0] = object(a0, z); @@ -823,7 +823,7 @@ struct define { pk.pack(a11); pk.pack(a12); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -831,26 +831,26 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*13); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*13)); o->via.array.size = 13; o->via.array.ptr[0] = object(a0, z); @@ -909,7 +909,7 @@ struct define { pk.pack(a12); pk.pack(a13); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -917,27 +917,27 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*14); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*14)); o->via.array.size = 14; o->via.array.ptr[0] = object(a0, z); @@ -999,7 +999,7 @@ struct define { pk.pack(a13); pk.pack(a14); } - void msgpack_unpack(msgpack::object o) + void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } const size_t size = o.via.array.size; @@ -1007,28 +1007,28 @@ struct define { msgpack::object *ptr = o.via.array.ptr; switch(size) { default: - case 15: ptr[14].convert(&a14); - case 14: ptr[13].convert(&a13); - case 13: ptr[12].convert(&a12); - case 12: ptr[11].convert(&a11); - case 11: ptr[10].convert(&a10); - case 10: ptr[9].convert(&a9); - case 9: ptr[8].convert(&a8); - case 8: ptr[7].convert(&a7); - case 7: ptr[6].convert(&a6); - case 6: ptr[5].convert(&a5); - case 5: ptr[4].convert(&a4); - case 4: ptr[3].convert(&a3); - case 3: ptr[2].convert(&a2); - case 2: ptr[1].convert(&a1); - case 1: ptr[0].convert(&a0); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); } } } void msgpack_object(msgpack::object* o, msgpack::zone* z) const { o->type = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*15); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*15)); o->via.array.size = 15; o->via.array.ptr[0] = object(a0, z); @@ -1093,7 +1093,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*16); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*16)); o->via.array.size = 16; o->via.array.ptr[0] = object(a0, z); @@ -1191,7 +1191,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*17); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*17)); o->via.array.size = 17; o->via.array.ptr[0] = object(a0, z); @@ -1293,7 +1293,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*18); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*18)); o->via.array.size = 18; o->via.array.ptr[0] = object(a0, z); @@ -1399,7 +1399,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*19); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*19)); o->via.array.size = 19; o->via.array.ptr[0] = object(a0, z); @@ -1509,7 +1509,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*20); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*20)); o->via.array.size = 20; o->via.array.ptr[0] = object(a0, z); @@ -1623,7 +1623,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*21); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*21)); o->via.array.size = 21; o->via.array.ptr[0] = object(a0, z); @@ -1741,7 +1741,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*22); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*22)); o->via.array.size = 22; o->via.array.ptr[0] = object(a0, z); @@ -1863,7 +1863,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*23); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*23)); o->via.array.size = 23; o->via.array.ptr[0] = object(a0, z); @@ -1989,7 +1989,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*24); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*24)); o->via.array.size = 24; o->via.array.ptr[0] = object(a0, z); @@ -2119,7 +2119,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*25); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*25)); o->via.array.size = 25; o->via.array.ptr[0] = object(a0, z); @@ -2253,7 +2253,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*26); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*26)); o->via.array.size = 26; o->via.array.ptr[0] = object(a0, z); @@ -2391,7 +2391,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*27); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*27)); o->via.array.size = 27; o->via.array.ptr[0] = object(a0, z); @@ -2533,7 +2533,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*28); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*28)); o->via.array.size = 28; o->via.array.ptr[0] = object(a0, z); @@ -2679,7 +2679,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*29); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*29)); o->via.array.size = 29; o->via.array.ptr[0] = object(a0, z); @@ -2829,7 +2829,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*30); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*30)); o->via.array.size = 30; o->via.array.ptr[0] = object(a0, z); @@ -2983,7 +2983,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*31); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*31)); o->via.array.size = 31; o->via.array.ptr[0] = object(a0, z); @@ -3141,7 +3141,7 @@ struct definetype = type::ARRAY; - o->via.array.ptr = (object*)z->malloc(sizeof(object)*32); + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*32)); o->via.array.size = 32; o->via.array.ptr[0] = object(a0, z); @@ -3461,5 +3461,5 @@ define struct tuple<> { tuple() {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } typedef tuple<> value_type; }; @@ -9185,7 +9185,7 @@ struct tuple { tuple() {} tuple(typename tuple_type::transparent_reference _a0) : a0(_a0) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9194,13 +9194,20 @@ struct tuple { A0 a0; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1) : a0(_a0), a1(_a1) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9210,13 +9217,20 @@ struct tuple { A1 a1; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2) : a0(_a0), a1(_a1), a2(_a2) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9227,13 +9241,20 @@ struct tuple { A2 a2; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3) : a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9245,13 +9266,20 @@ struct tuple { A3 a3; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9264,13 +9292,20 @@ struct tuple { A4 a4; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9284,13 +9319,20 @@ struct tuple { A5 a5; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9305,13 +9347,20 @@ struct tuple { A6 a6; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9327,13 +9376,20 @@ struct tuple { A7 a7; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9350,13 +9406,20 @@ struct tuple { A8 a8; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9374,13 +9437,20 @@ struct tuple { A9 a9; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9399,13 +9469,20 @@ struct tuple { A10 a10; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11) : a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9425,13 +9502,20 @@ struct tuple { A11 a11; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9452,13 +9536,20 @@ struct tuple { A12 a12; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9480,13 +9571,20 @@ struct tuple { A13 a13; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9509,13 +9607,20 @@ struct tuple { A14 a14; }; +template +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9539,13 +9644,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9570,13 +9682,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9602,13 +9721,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9635,13 +9761,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9669,13 +9802,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9704,13 +9844,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9740,13 +9887,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9777,13 +9931,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9815,13 +9976,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9854,13 +10022,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9894,13 +10069,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9935,13 +10117,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -9977,13 +10166,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -10020,13 +10216,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -10064,13 +10267,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -10109,13 +10319,20 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + template struct tuple { typedef tuple value_type; tuple() {} tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30, typename tuple_type::transparent_reference _a31) : 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) {} - tuple(object o) { o.convert(this); } + tuple(object const& o) { o.convert(*this); } template typename tuple_element::reference get() { return tuple_element(*this).get(); } template typename const_tuple_element::const_reference get() const @@ -10155,6 +10372,13 @@ struct tuple +inline typename type::tuple_element, N>::reference get(type::tuple& t) +{ return t.template get(); } +template +inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) +{ return t.template get(); } + inline tuple<> make_tuple() { @@ -10356,9 +10580,8 @@ tuple& operator>> ( - object o, + object const& o, type::tuple<>& v) { if(o.type != type::ARRAY) { throw type_error(); } return v; @@ -10366,849 +10589,849 @@ inline type::tuple<>& operator>> ( template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 1) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 2) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 3) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 4) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 5) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 6) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 7) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 8) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 9) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 10) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 11) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 12) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 13) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 14) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 15) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 16) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 17) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 18) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 19) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 20) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 21) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 22) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 23) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 24) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 25) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 26) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 27) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 28) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 29) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 30) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); - o.via.array.ptr[29].convert::type>(&v.template get<29>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 31) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); - o.via.array.ptr[29].convert::type>(&v.template get<29>()); - o.via.array.ptr[30].convert::type>(&v.template get<30>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + o.via.array.ptr[30].convert::type>(v.template get<30>()); return v; } template type::tuple& operator>> ( - object o, + object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 32) { throw type_error(); } - o.via.array.ptr[0].convert::type>(&v.template get<0>()); - o.via.array.ptr[1].convert::type>(&v.template get<1>()); - o.via.array.ptr[2].convert::type>(&v.template get<2>()); - o.via.array.ptr[3].convert::type>(&v.template get<3>()); - o.via.array.ptr[4].convert::type>(&v.template get<4>()); - o.via.array.ptr[5].convert::type>(&v.template get<5>()); - o.via.array.ptr[6].convert::type>(&v.template get<6>()); - o.via.array.ptr[7].convert::type>(&v.template get<7>()); - o.via.array.ptr[8].convert::type>(&v.template get<8>()); - o.via.array.ptr[9].convert::type>(&v.template get<9>()); - o.via.array.ptr[10].convert::type>(&v.template get<10>()); - o.via.array.ptr[11].convert::type>(&v.template get<11>()); - o.via.array.ptr[12].convert::type>(&v.template get<12>()); - o.via.array.ptr[13].convert::type>(&v.template get<13>()); - o.via.array.ptr[14].convert::type>(&v.template get<14>()); - o.via.array.ptr[15].convert::type>(&v.template get<15>()); - o.via.array.ptr[16].convert::type>(&v.template get<16>()); - o.via.array.ptr[17].convert::type>(&v.template get<17>()); - o.via.array.ptr[18].convert::type>(&v.template get<18>()); - o.via.array.ptr[19].convert::type>(&v.template get<19>()); - o.via.array.ptr[20].convert::type>(&v.template get<20>()); - o.via.array.ptr[21].convert::type>(&v.template get<21>()); - o.via.array.ptr[22].convert::type>(&v.template get<22>()); - o.via.array.ptr[23].convert::type>(&v.template get<23>()); - o.via.array.ptr[24].convert::type>(&v.template get<24>()); - o.via.array.ptr[25].convert::type>(&v.template get<25>()); - o.via.array.ptr[26].convert::type>(&v.template get<26>()); - o.via.array.ptr[27].convert::type>(&v.template get<27>()); - o.via.array.ptr[28].convert::type>(&v.template get<28>()); - o.via.array.ptr[29].convert::type>(&v.template get<29>()); - o.via.array.ptr[30].convert::type>(&v.template get<30>()); - o.via.array.ptr[31].convert::type>(&v.template get<31>()); + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + o.via.array.ptr[30].convert::type>(v.template get<30>()); + o.via.array.ptr[31].convert::type>(v.template get<31>()); return v; } @@ -12042,7 +12265,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple<>& v) { o.type = type::ARRAY; - o.via.array.ptr = NULL; + o.via.array.ptr = nullptr; o.via.array.size = 0; } @@ -12051,7 +12274,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*1); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*1)); o.via.array.size = 1; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12062,7 +12285,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*2); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*2)); o.via.array.size = 2; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12074,7 +12297,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*3); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*3)); o.via.array.size = 3; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12087,7 +12310,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*4); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*4)); o.via.array.size = 4; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12101,7 +12324,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*5); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*5)); o.via.array.size = 5; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12116,7 +12339,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*6); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*6)); o.via.array.size = 6; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12132,7 +12355,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*7); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*7)); o.via.array.size = 7; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12149,7 +12372,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*8); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*8)); o.via.array.size = 8; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12167,7 +12390,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*9); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*9)); o.via.array.size = 9; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12186,7 +12409,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*10); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*10)); o.via.array.size = 10; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12206,7 +12429,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*11); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*11)); o.via.array.size = 11; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12227,7 +12450,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*12); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*12)); o.via.array.size = 12; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12249,7 +12472,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*13); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*13)); o.via.array.size = 13; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12272,7 +12495,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*14); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*14)); o.via.array.size = 14; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12296,7 +12519,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*15); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*15)); o.via.array.size = 15; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12321,7 +12544,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*16); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*16)); o.via.array.size = 16; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12347,7 +12570,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*17); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*17)); o.via.array.size = 17; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12374,7 +12597,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*18); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*18)); o.via.array.size = 18; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12402,7 +12625,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*19); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*19)); o.via.array.size = 19; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12431,7 +12654,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*20); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*20)); o.via.array.size = 20; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12461,7 +12684,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*21); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*21)); o.via.array.size = 21; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12492,7 +12715,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*22); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*22)); o.via.array.size = 22; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12524,7 +12747,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*23); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*23)); o.via.array.size = 23; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12557,7 +12780,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*24); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*24)); o.via.array.size = 24; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12591,7 +12814,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*25); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*25)); o.via.array.size = 25; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12626,7 +12849,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*26); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*26)); o.via.array.size = 26; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12662,7 +12885,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*27); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*27)); o.via.array.size = 27; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12699,7 +12922,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*28); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*28)); o.via.array.size = 28; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12737,7 +12960,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*29); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*29)); o.via.array.size = 29; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12776,7 +12999,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*30); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*30)); o.via.array.size = 30; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12816,7 +13039,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*31); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*31)); o.via.array.size = 31; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12857,7 +13080,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*32); + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*32)); o.via.array.size = 32; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -13687,5 +13910,4 @@ inline void operator<< ( //} // -#endif /* msgpack/type/tuple.hpp */ - +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP diff --git a/cpp11/define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp similarity index 96% rename from cpp11/define.hpp rename to include/msgpack/adaptor/detail/cpp11_define.hpp index 0f09c3aa..e43eb86c 100644 --- a/cpp11/define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_DEFINE_HPP -#define MSGPACK_TYPE_DEFINE_HPP +#ifndef MSGPACK_CPP11_DEFINE_HPP +#define MSGPACK_CPP11_DEFINE_HPP #define MSGPACK_DEFINE(...) \ template \ @@ -46,7 +46,7 @@ return v; \ } \ template <> \ - void operator<< (object::with_zone& o, const enum& v) \ + inline void operator<< (object::with_zone& o, const enum& v) \ { \ int tmp = static_cast(v); \ o << tmp; \ @@ -165,6 +165,4 @@ define make_define(Args&... args) } // namespace type } // namespace msgpack - -#endif /* msgpack/type/define.hpp */ - +#endif // MSGPACK_CPP11_DEFINE_HPP diff --git a/cpp11/tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp similarity index 97% rename from cpp11/tuple.hpp rename to include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 1d068a37..98041bb4 100644 --- a/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -15,8 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_TYPE_TUPLE_HPP -#define MSGPACK_TYPE_TUPLE_HPP +#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP +#define MSGPACK_CPP11_MSGPACK_TUPLE_HPP #include @@ -181,5 +181,5 @@ inline void operator<< ( } // msgpack -#endif /* msgpack/type/tuple.hpp */ +#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP diff --git a/src/msgpack/type/fixint.hpp b/include/msgpack/adaptor/fixint.hpp similarity index 99% rename from src/msgpack/type/fixint.hpp rename to include/msgpack/adaptor/fixint.hpp index e68a83ad..16380beb 100644 --- a/src/msgpack/type/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_FIXINT_HPP #include "msgpack/object.hpp" -#include "msgpack/type/int.hpp" +#include "msgpack/adaptor/int.hpp" namespace msgpack { diff --git a/src/msgpack/type/float.hpp b/include/msgpack/adaptor/float.hpp similarity index 100% rename from src/msgpack/type/float.hpp rename to include/msgpack/adaptor/float.hpp diff --git a/src/msgpack/type/int.hpp b/include/msgpack/adaptor/int.hpp similarity index 100% rename from src/msgpack/type/int.hpp rename to include/msgpack/adaptor/int.hpp diff --git a/src/msgpack/type/list.hpp b/include/msgpack/adaptor/list.hpp similarity index 100% rename from src/msgpack/type/list.hpp rename to include/msgpack/adaptor/list.hpp diff --git a/src/msgpack/type/map.hpp b/include/msgpack/adaptor/map.hpp similarity index 100% rename from src/msgpack/type/map.hpp rename to include/msgpack/adaptor/map.hpp diff --git a/include/msgpack/adaptor/msgpack_tuple.hpp b/include/msgpack/adaptor/msgpack_tuple.hpp new file mode 100644 index 00000000..57fd4ba5 --- /dev/null +++ b/include/msgpack/adaptor/msgpack_tuple.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_MSGPACK_TUPLE_HPP +#define MSGPACK_MSGPACK_TUPLE_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_msgpack_tuple.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_msgpack_tuple.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_MSGPACK_TUPLE_HPP diff --git a/src/msgpack/type/nil.hpp b/include/msgpack/adaptor/nil.hpp similarity index 100% rename from src/msgpack/type/nil.hpp rename to include/msgpack/adaptor/nil.hpp diff --git a/src/msgpack/type/pair.hpp b/include/msgpack/adaptor/pair.hpp similarity index 100% rename from src/msgpack/type/pair.hpp rename to include/msgpack/adaptor/pair.hpp diff --git a/src/msgpack/type/raw.hpp b/include/msgpack/adaptor/raw.hpp similarity index 100% rename from src/msgpack/type/raw.hpp rename to include/msgpack/adaptor/raw.hpp diff --git a/src/msgpack/type/set.hpp b/include/msgpack/adaptor/set.hpp similarity index 100% rename from src/msgpack/type/set.hpp rename to include/msgpack/adaptor/set.hpp diff --git a/src/msgpack/type/string.hpp b/include/msgpack/adaptor/string.hpp similarity index 100% rename from src/msgpack/type/string.hpp rename to include/msgpack/adaptor/string.hpp diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp similarity index 100% rename from src/msgpack/type/tr1/unordered_map.hpp rename to include/msgpack/adaptor/tr1/unordered_map.hpp diff --git a/src/msgpack/type/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp similarity index 100% rename from src/msgpack/type/tr1/unordered_set.hpp rename to include/msgpack/adaptor/tr1/unordered_set.hpp diff --git a/src/msgpack/type/vector.hpp b/include/msgpack/adaptor/vector.hpp similarity index 100% rename from src/msgpack/type/vector.hpp rename to include/msgpack/adaptor/vector.hpp diff --git a/src/msgpack/cpp_config.hpp b/include/msgpack/cpp_config.hpp similarity index 86% rename from src/msgpack/cpp_config.hpp rename to include/msgpack/cpp_config.hpp index 596bef9d..e088a3d5 100644 --- a/src/msgpack/cpp_config.hpp +++ b/include/msgpack/cpp_config.hpp @@ -18,6 +18,17 @@ #ifndef MSGPACK_CPP_CONFIG_HPP #define MSGPACK_CPP_CONFIG_HPP +#if !defined(MSGPACK_USE_CPP03) + // If MSVC would support C++11 completely, + // then 'defined(_MSC_VER)' would replace with + // '_MSC_VER < XXXX' +# if (__cplusplus < 201103) || defined(_MSC_VER) +# define MSGPACK_USE_CPP03 +# endif +#endif // MSGPACK_USE_CPP03 + + + #if defined __cplusplus #if __cplusplus < 201103 @@ -25,6 +36,8 @@ #define nullptr (0) #endif +#include + namespace msgpack { template diff --git a/src/msgpack/zone.hpp b/include/msgpack/detail/cpp03_zone.hpp similarity index 51% rename from src/msgpack/zone.hpp rename to include/msgpack/detail/cpp03_zone.hpp index 692fbf8c..4afc8cca 100644 --- a/src/msgpack/zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -3,43 +3,164 @@ // // Copyright (C) 2008-2010 FURUHASHI Sadayuki // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at // -// http://www.apache.org/licenses/LICENSE-2.0 +// http://www.apache.org/licenses/LICENSE-2.0 // -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. // -#ifndef MSGPACK_ZONE_HPP__ -#define MSGPACK_ZONE_HPP__ +#ifndef MSGPACK_CPP03_ZONE_HPP +#define MSGPACK_CPP03_ZONE_HPP -#include "zone.h" #include #include #include +#include "msgpack/cpp_config.hpp" + +#ifndef MSGPACK_ZONE_CHUNK_SIZE +#define MSGPACK_ZONE_CHUNK_SIZE 8192 +#endif + +#ifndef MSGPACK_ZONE_ALIGN +#define MSGPACK_ZONE_ALIGN sizeof(int) +#endif + namespace msgpack { +class zone { + struct finalizer { + finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} + void operator()() { func_(data_); } + void (*func_)(void*); + void* data_; + }; + struct finalizer_array { + finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} + void call() { + finalizer* fin = tail_; + for(; fin != array_; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(array_); + } + void clear() { + call(); + tail_ = array_; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = tail_; -class zone : public msgpack_zone { -public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE); - ~zone(); + if(fin == end_) { + push_expand(func, data); + return; + } + + fin->func_ = func; + fin->data_ = data; + + ++tail_; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = end_ - array_; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(array_, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + array_ = tmp; + end_ = tmp + nnext; + tail_ = tmp + nused; + new (tail_) finalizer(func, data); + + ++tail_; + } + finalizer* tail_; + finalizer* end_; + finalizer* array_; + }; + struct chunk { + chunk* next_; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } + + head_ = c; + free_ = chunk_size; + ptr_ = reinterpret_cast(c) + sizeof(chunk); + c->next_ = nullptr; + } + ~chunk_list() + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + ::free(c); + if(n) { + c = n; + } else { + break; + } + } + } + void clear(size_t chunk_size) + { + chunk* c = head_; + while(true) { + chunk* n = c->next_; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + head_->next_ = nullptr; + free_ = chunk_size; + ptr_ = reinterpret_cast(head_) + sizeof(chunk); + } + size_t free_; + char* ptr_; + chunk* head_; + }; + size_t chunk_size_; + chunk_list chunk_list_; + finalizer_array finalizer_array_; public: - void* malloc(size_t size); - void* malloc_no_align(size_t size); + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; + +public: + static zone* create(size_t chunk_size); + static void destroy(zone* zone); + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); void push_finalizer(void (*func)(void*), void* data); template - void push_finalizer(std::auto_ptr obj); + void push_finalizer(msgpack::unique_ptr obj); void clear(); @@ -54,6 +175,14 @@ public: { ::free(p); } + static void* operator new(std::size_t size, void* place) throw() + { + return ::operator new(size, place); + } + static void operator delete(void* p, void* place) throw() + { + ::operator delete(p, place); + } template T* allocate(); @@ -105,71 +234,97 @@ public: private: - void undo_malloc(size_t size); + void undo_allocate(size_t size); template static void object_destructor(void* obj); - typedef msgpack_zone base; - -private: - zone(const zone&); + void* allocate_expand(size_t size); }; - -inline zone::zone(size_t chunk_size) +inline zone* zone::create(size_t chunk_size) { - msgpack_zone_init(this, chunk_size); -} - -inline zone::~zone() -{ - msgpack_zone_destroy(this); -} - -inline void* zone::malloc(size_t size) -{ - void* ptr = msgpack_zone_malloc(this, size); - if(!ptr) { - throw std::bad_alloc(); + zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); + if (!z) { + return nullptr; } + new (z) zone(chunk_size); + return z; +} + +inline void zone::destroy(zone* z) +{ + z->~zone(); + ::free(z); +} + +inline zone::zone(size_t chunk_size) /* throw() */ :chunk_size_(chunk_size), chunk_list_(chunk_size_) +{ +} + +inline void* zone::allocate_align(size_t size) +{ + return allocate_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); +} + +inline void* zone::allocate_no_align(size_t size) +{ + if(chunk_list_.free_ < size) { + return allocate_expand(size); + } + + char* ptr = chunk_list_.ptr_; + chunk_list_.free_ -= size; + chunk_list_.ptr_ += size; + return ptr; } -inline void* zone::malloc_no_align(size_t size) +inline void* zone::allocate_expand(size_t size) { - void* ptr = msgpack_zone_malloc_no_align(this, size); - if(!ptr) { - throw std::bad_alloc(); + chunk_list* const cl = &chunk_list_; + + size_t sz = chunk_size_; + + while(sz < size) { + sz *= 2; } + + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + + char* ptr = reinterpret_cast(c) + sizeof(chunk); + + c->next_ = cl->head_; + cl->head_ = c; + cl->free_ = sz - size; + cl->ptr_ = ptr + size; + return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - if(!msgpack_zone_push_finalizer(this, func, data)) { - throw std::bad_alloc(); - } + finalizer_array_.push(func, data); } template -inline void zone::push_finalizer(std::auto_ptr obj) +inline void zone::push_finalizer(msgpack::unique_ptr obj) { - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, obj.get())) { - throw std::bad_alloc(); - } + finalizer_array_.push(&zone::object_destructor, obj.get()); obj.release(); } inline void zone::clear() { - msgpack_zone_clear(this); + finalizer_array_.clear(); + chunk_list_.clear(chunk_size_); } inline void zone::swap(zone& o) { - msgpack_zone_swap(this, &o); + std::swap(*this, o); } template @@ -178,26 +333,28 @@ void zone::object_destructor(void* obj) reinterpret_cast(obj)->~T(); } -inline void zone::undo_malloc(size_t size) +inline void zone::undo_allocate(size_t size) { - base::chunk_list.ptr -= size; - base::chunk_list.free += size; + chunk_list_.ptr_ -= size; + chunk_list_.free_ += size; } template T* zone::allocate() { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -205,16 +362,18 @@ T* zone::allocate() template T* zone::allocate(A1 a1) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -222,16 +381,18 @@ T* zone::allocate(A1 a1) template T* zone::allocate(A1 a1, A2 a2) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -239,16 +400,18 @@ T* zone::allocate(A1 a1, A2 a2) template T* zone::allocate(A1 a1, A2 a2, A3 a3) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -256,16 +419,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3) template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -273,16 +438,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -290,16 +457,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -307,16 +476,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -324,16 +495,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -341,16 +514,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -358,16 +533,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -375,16 +552,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -392,16 +571,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -409,16 +590,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, template T* zone::allocate(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) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -426,16 +609,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, template T* zone::allocate(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) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -443,16 +628,18 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, template T* zone::allocate(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) { - void* x = malloc(sizeof(T)); - if(!msgpack_zone_push_finalizer(this, &zone::object_destructor, x)) { - undo_malloc(sizeof(T)); - throw std::bad_alloc(); + void* x = allocate_align(sizeof(T)); + try { + finalizer_array_.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; } try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); } catch (...) { - --base::finalizer_array.tail; - undo_malloc(sizeof(T)); + --finalizer_array_.tail_; + undo_allocate(sizeof(T)); throw; } } @@ -460,5 +647,4 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, } // namespace msgpack -#endif /* msgpack/zone.hpp */ - +#endif // MSGPACK_CPP03_ZONE_HPP diff --git a/cpp11/zone.hpp b/include/msgpack/detail/cpp11_zone.hpp similarity index 97% rename from cpp11/zone.hpp rename to include/msgpack/detail/cpp11_zone.hpp index 9a99e650..db4b0e88 100644 --- a/cpp11/zone.hpp +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -15,14 +15,14 @@ // See the License for the specific language governing permissions and // limitations under the License. // -#ifndef MSGPACK_ZONE_HPP -#define MSGPACK_ZONE_HPP +#ifndef MSGPACK_CPP11_ZONE_HPP +#define MSGPACK_CPP11_ZONE_HPP #include #include #include -#include "cpp_config.hpp" +#include "msgpack/cpp_config.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 @@ -317,4 +317,4 @@ T* zone::allocate(Args... args) } // namespace msgpack -#endif /* msgpack/zone.hpp */ +#endif // MSGPACK_CPP11_ZONE_HPP diff --git a/src/msgpack/fbuffer.h b/include/msgpack/fbuffer.h similarity index 100% rename from src/msgpack/fbuffer.h rename to include/msgpack/fbuffer.h diff --git a/src/msgpack/fbuffer.hpp b/include/msgpack/fbuffer.hpp similarity index 100% rename from src/msgpack/fbuffer.hpp rename to include/msgpack/fbuffer.hpp diff --git a/src/gcc_atomic.h b/include/msgpack/gcc_atomic.h similarity index 100% rename from src/gcc_atomic.h rename to include/msgpack/gcc_atomic.h diff --git a/src/msgpack/object.h b/include/msgpack/object.h similarity index 100% rename from src/msgpack/object.h rename to include/msgpack/object.h diff --git a/src/msgpack/object.hpp b/include/msgpack/object.hpp similarity index 100% rename from src/msgpack/object.hpp rename to include/msgpack/object.hpp diff --git a/src/msgpack/pack.h b/include/msgpack/pack.h similarity index 100% rename from src/msgpack/pack.h rename to include/msgpack/pack.h diff --git a/src/msgpack/pack.hpp b/include/msgpack/pack.hpp similarity index 100% rename from src/msgpack/pack.hpp rename to include/msgpack/pack.hpp diff --git a/src/msgpack/pack_define.h b/include/msgpack/pack_define.h similarity index 100% rename from src/msgpack/pack_define.h rename to include/msgpack/pack_define.h diff --git a/src/msgpack/pack_template.h b/include/msgpack/pack_template.h similarity index 100% rename from src/msgpack/pack_template.h rename to include/msgpack/pack_template.h diff --git a/src/msgpack/sbuffer.h b/include/msgpack/sbuffer.h similarity index 100% rename from src/msgpack/sbuffer.h rename to include/msgpack/sbuffer.h diff --git a/src/msgpack/sbuffer.hpp b/include/msgpack/sbuffer.hpp similarity index 100% rename from src/msgpack/sbuffer.hpp rename to include/msgpack/sbuffer.hpp diff --git a/src/msgpack/sysdep.h b/include/msgpack/sysdep.h similarity index 100% rename from src/msgpack/sysdep.h rename to include/msgpack/sysdep.h diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp new file mode 100644 index 00000000..6a728623 --- /dev/null +++ b/include/msgpack/type.hpp @@ -0,0 +1,17 @@ +#include "adaptor/bool.hpp" +#include "adaptor/deque.hpp" +#include "adaptor/fixint.hpp" +#include "adaptor/float.hpp" +#include "adaptor/int.hpp" +#include "adaptor/list.hpp" +#include "adaptor/map.hpp" +#include "adaptor/nil.hpp" +#include "adaptor/pair.hpp" +#include "adaptor/raw.hpp" +#include "adaptor/set.hpp" +#include "adaptor/string.hpp" +#include "adaptor/vector.hpp" +#include "adaptor/msgpack_tuple.hpp" +#include "adaptor/define.hpp" +#include "adaptor/tr1/unordered_map.hpp" +#include "adaptor/tr1/unordered_set.hpp" diff --git a/src/msgpack/unpack.h b/include/msgpack/unpack.h similarity index 100% rename from src/msgpack/unpack.h rename to include/msgpack/unpack.h diff --git a/src/msgpack/unpack.hpp b/include/msgpack/unpack.hpp similarity index 100% rename from src/msgpack/unpack.hpp rename to include/msgpack/unpack.hpp diff --git a/src/msgpack/unpack_define.h b/include/msgpack/unpack_define.h similarity index 100% rename from src/msgpack/unpack_define.h rename to include/msgpack/unpack_define.h diff --git a/src/msgpack/unpack_template.h b/include/msgpack/unpack_template.h similarity index 100% rename from src/msgpack/unpack_template.h rename to include/msgpack/unpack_template.h diff --git a/src/msgpack/version.h.in b/include/msgpack/version.h similarity index 77% rename from src/msgpack/version.h.in rename to include/msgpack/version.h index 418ae4a2..2a324e5c 100644 --- a/src/msgpack/version.h.in +++ b/include/msgpack/version.h @@ -27,10 +27,12 @@ const char* msgpack_version(void); int msgpack_version_major(void); int msgpack_version_minor(void); -#define MSGPACK_VERSION "@VERSION@" -#define MSGPACK_VERSION_MAJOR @VERSION_MAJOR@ -#define MSGPACK_VERSION_MINOR @VERSION_MINOR@ +#include "version_master.h" +#define MSGPACK_STR(v) #v +#define MSGPACK_VERSION_I(maj, min, rel) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rel) + +#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_RELEASE) #ifdef __cplusplus } diff --git a/src/msgpack/version.hpp.in b/include/msgpack/version.hpp similarity index 79% rename from src/msgpack/version.hpp.in rename to include/msgpack/version.hpp index f13ab0b7..48f59360 100644 --- a/src/msgpack/version.hpp.in +++ b/include/msgpack/version.hpp @@ -18,9 +18,12 @@ #ifndef MSGPACK_VERSION_HPP #define MSGPACK_VERSION_HPP -#define MSGPACK_VERSION "@VERSION@" -#define MSGPACK_VERSION_MAJOR @VERSION_MAJOR@ -#define MSGPACK_VERSION_MINOR @VERSION_MINOR@ +#include "version_master.h" + +#define MSGPACK_STR(v) #v +#define MSGPACK_VERSION_I(maj, min, rel) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rel) + +#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_RELEASE) inline const char* msgpack_version(void) { return MSGPACK_VERSION; diff --git a/include/msgpack/version_master.h b/include/msgpack/version_master.h new file mode 100644 index 00000000..799f4f5e --- /dev/null +++ b/include/msgpack/version_master.h @@ -0,0 +1,3 @@ +#define MSGPACK_VERSION_MAJOR 0 +#define MSGPACK_VERSION_MINOR 5 +#define MSGPACK_VERSION_RELEASE 9 diff --git a/src/msgpack/vrefbuffer.h b/include/msgpack/vrefbuffer.h similarity index 100% rename from src/msgpack/vrefbuffer.h rename to include/msgpack/vrefbuffer.h diff --git a/src/msgpack/vrefbuffer.hpp b/include/msgpack/vrefbuffer.hpp similarity index 100% rename from src/msgpack/vrefbuffer.hpp rename to include/msgpack/vrefbuffer.hpp diff --git a/src/msgpack/zbuffer.h b/include/msgpack/zbuffer.h similarity index 100% rename from src/msgpack/zbuffer.h rename to include/msgpack/zbuffer.h diff --git a/src/msgpack/zbuffer.hpp b/include/msgpack/zbuffer.hpp similarity index 100% rename from src/msgpack/zbuffer.hpp rename to include/msgpack/zbuffer.hpp diff --git a/src/msgpack/zone.h b/include/msgpack/zone.h similarity index 100% rename from src/msgpack/zone.h rename to include/msgpack/zone.h diff --git a/include/msgpack/zone.hpp b/include/msgpack/zone.hpp new file mode 100644 index 00000000..c019fb05 --- /dev/null +++ b/include/msgpack/zone.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ memory pool +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_ZONE_HPP +#define MSGPACK_ZONE_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_zone.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_zone.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_ZONE_HPP diff --git a/preprocess b/preprocess index 96280d59..5efab359 100755 --- a/preprocess +++ b/preprocess @@ -8,10 +8,10 @@ preprocess() { echo "" exit 1 else - mv $1.tmp $1 + mv $1.tmp $2 fi } -preprocess src/msgpack/type/tuple.hpp -preprocess src/msgpack/type/define.hpp -preprocess src/msgpack/zone.hpp +preprocess erb/cpp03_msgpack_tuple.hpp include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +preprocess erb/cpp03_define.hpp include/msgpack/adaptor/detail/cpp03_define.hpp +preprocess erb/cpp03_zone.hpp include/msgpack/detail/cpp03_zone.hpp diff --git a/preprocess_cpp11 b/preprocess_cpp11 deleted file mode 100755 index d7b01d33..00000000 --- a/preprocess_cpp11 +++ /dev/null @@ -1,17 +0,0 @@ -#!/bin/sh - -if [ "$1" = "clean" ];then - rm -f src/msgpack/type/tuple.hpp - rm -f src/msgpack/type/define.hpp - rm -f src/msgpack/zone.hpp -else - cp -f cpp11/zone.hpp src/msgpack/ - cp -f cpp11/tuple.hpp src/msgpack/type/ - cp -f cpp11/define.hpp src/msgpack/type/ -fi -cp -f cases.mpac test/ -cp -f cases_compact.mpac test/ - -sed -e 's/8\.00/9.00/' < msgpack_vc8.vcproj > msgpack_vc2008.vcproj -sed -e 's/9\.00/10.00/' -e 's/msgpack_vc8/msgpack_vc2008/' < msgpack_vc8.sln > msgpack_vc2008.sln - diff --git a/src/Makefile.am b/src/Makefile.am index 48b9c86b..106947a7 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1,6 +1,8 @@ lib_LTLIBRARIES = libmsgpack.la +AM_CPPFLAGS = -I../include + libmsgpack_la_SOURCES = \ unpack.c \ objectc.c \ @@ -31,60 +33,62 @@ libmsgpackc_la_LDFLAGS = -version-info 2:0:0 -no-undefined nobase_include_HEADERS = \ - msgpack/pack_define.h \ - msgpack/pack_template.h \ - msgpack/unpack_define.h \ - msgpack/unpack_template.h \ - msgpack/sysdep.h \ - msgpack.h \ - msgpack/sbuffer.h \ - msgpack/version.h \ - msgpack/vrefbuffer.h \ - msgpack/zbuffer.h \ - msgpack/fbuffer.h \ - msgpack/pack.h \ - msgpack/unpack.h \ - msgpack/object.h \ - msgpack/zone.h + ../include/msgpack/pack_define.h \ + ../include/msgpack/pack_template.h \ + ../include/msgpack/unpack_define.h \ + ../include/msgpack/unpack_template.h \ + ../include/msgpack/sysdep.h \ + ../include/msgpack.h \ + ../include/msgpack/sbuffer.h \ + ../include/msgpack/version.h \ + ../include/msgpack/version_master.h \ + ../include/msgpack/vrefbuffer.h \ + ../include/msgpack/zbuffer.h \ + ../include/msgpack/fbuffer.h \ + ../include/msgpack/pack.h \ + ../include/msgpack/unpack.h \ + ../include/msgpack/object.h \ + ../include/msgpack/zone.h if ENABLE_CXX nobase_include_HEADERS += \ - msgpack.hpp \ - msgpack/sbuffer.hpp \ - msgpack/vrefbuffer.hpp \ - msgpack/zbuffer.hpp \ - msgpack/fbuffer.hpp \ - msgpack/pack.hpp \ - msgpack/unpack.hpp \ - msgpack/version.hpp \ - msgpack/object.hpp \ - msgpack/zone.hpp \ - msgpack/type.hpp \ - msgpack/type/bool.hpp \ - msgpack/type/deque.hpp \ - msgpack/type/float.hpp \ - msgpack/type/fixint.hpp \ - msgpack/type/int.hpp \ - msgpack/type/list.hpp \ - msgpack/type/map.hpp \ - msgpack/type/nil.hpp \ - msgpack/type/pair.hpp \ - msgpack/type/raw.hpp \ - msgpack/type/set.hpp \ - msgpack/type/string.hpp \ - msgpack/type/vector.hpp \ - msgpack/type/tuple.hpp \ - msgpack/type/define.hpp \ - msgpack/type/tr1/unordered_map.hpp \ - msgpack/type/tr1/unordered_set.hpp + ../include/msgpack.hpp \ + ../include/msgpack/sbuffer.hpp \ + ../include/msgpack/vrefbuffer.hpp \ + ../include/msgpack/zbuffer.hpp \ + ../include/msgpack/fbuffer.hpp \ + ../include/msgpack/pack.hpp \ + ../include/msgpack/unpack.hpp \ + ../include/msgpack/version.hpp \ + ../include/msgpack/object.hpp \ + ../include/msgpack/zone.hpp \ + ../include/msgpack/type.hpp \ + ../include/msgpack/detail/cpp11_zone.hpp \ + ../include/msgpack/adaptor/bool.hpp \ + ../include/msgpack/adaptor/deque.hpp \ + ../include/msgpack/adaptor/float.hpp \ + ../include/msgpack/adaptor/fixint.hpp \ + ../include/msgpack/adaptor/int.hpp \ + ../include/msgpack/adaptor/list.hpp \ + ../include/msgpack/adaptor/map.hpp \ + ../include/msgpack/adaptor/nil.hpp \ + ../include/msgpack/adaptor/pair.hpp \ + ../include/msgpack/adaptor/raw.hpp \ + ../include/msgpack/adaptor/set.hpp \ + ../include/msgpack/adaptor/string.hpp \ + ../include/msgpack/adaptor/vector.hpp \ + ../include/msgpack/adaptor/msgpack_tuple.hpp \ + ../include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp \ + ../include/msgpack/adaptor/define.hpp \ + ../include/msgpack/adaptor/detail/cpp11_define.hpp \ + ../include/msgpack/adaptor/tr1/unordered_map.hpp \ + ../include/msgpack/adaptor/tr1/unordered_set.hpp endif EXTRA_DIST = \ - msgpack/version.h.in \ - msgpack/version.hpp.in \ - msgpack/zone.hpp.erb \ - msgpack/type/define.hpp.erb \ - msgpack/type/tuple.hpp.erb + ../erb/cpp03_zone.hpp.erb \ + ../erb/cpp03_define.hpp.erb \ + ../erb/cpp03_msgpack_tuple.hpp.erb doxygen_c: diff --git a/src/gcc_atomic.hpp b/src/gcc_atomic.hpp index 283e9dc7..8b5c087e 100644 --- a/src/gcc_atomic.hpp +++ b/src/gcc_atomic.hpp @@ -22,7 +22,7 @@ #ifdef ENABLE_GCC_CXX_ATOMIC #if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) -#include "gcc_atomic.h" +#include "msgpack/gcc_atomic.h" #include int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) diff --git a/src/msgpack/type.hpp b/src/msgpack/type.hpp deleted file mode 100644 index 1f51319a..00000000 --- a/src/msgpack/type.hpp +++ /dev/null @@ -1,17 +0,0 @@ -#include "type/bool.hpp" -#include "type/deque.hpp" -#include "type/fixint.hpp" -#include "type/float.hpp" -#include "type/int.hpp" -#include "type/list.hpp" -#include "type/map.hpp" -#include "type/nil.hpp" -#include "type/pair.hpp" -#include "type/raw.hpp" -#include "type/set.hpp" -#include "type/string.hpp" -#include "type/vector.hpp" -#include "type/tuple.hpp" -#include "type/define.hpp" -#include "type/tr1/unordered_map.hpp" -#include "type/tr1/unordered_set.hpp" diff --git a/test/Makefile.am b/test/Makefile.am index 08efc428..b7e9d00c 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -1,6 +1,6 @@ -AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src -AM_C_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src +AM_CPPFLAGS = -I$(top_srcdir)/include +AM_C_CPPFLAGS = -I$(top_srcdir)/include AM_LDFLAGS = $(top_builddir)/src/libmsgpack.la -lgtest_main -lgtest -pthread check_PROGRAMS = \ diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index bacf6de3..9673ed91 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -508,7 +508,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) #ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP #include -#include "msgpack/type/tr1/unordered_map.hpp" +#include "msgpack/adaptor/tr1/unordered_map.hpp" TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) { for (unsigned int k = 0; k < kLoop; k++) { @@ -569,7 +569,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) #ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET #include -#include "msgpack/type/tr1/unordered_set.hpp" +#include "msgpack/adaptor/tr1/unordered_set.hpp" TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) { for (unsigned int k = 0; k < kLoop; k++) { @@ -625,7 +625,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) #ifdef MSGPACK_HAS_STD_UNOURDERED_MAP #include -#include "msgpack/type/tr1/unordered_map.hpp" +#include "msgpack/adaptor/tr1/unordered_map.hpp" TEST(MSGPACK_TR1, simple_buffer_unordered_map) { for (unsigned int k = 0; k < kLoop; k++) { @@ -686,7 +686,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) #ifdef MSGPACK_HAS_STD_UNOURDERED_SET #include -#include "msgpack/type/tr1/unordered_set.hpp" +#include "msgpack/adaptor/tr1/unordered_set.hpp" TEST(MSGPACK_TR1, simple_buffer_unordered_set) { for (unsigned int k = 0; k < kLoop; k++) { From dac5c60608212494b84e244f3fe55f5b2d6a8174 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 31 Mar 2014 16:02:29 +0900 Subject: [PATCH 073/153] Replaced bit shift with memcpy on load. --- include/msgpack/pack.hpp | 10 +- include/msgpack/sysdep.h | 52 +++-------- include/msgpack/unpack.hpp | 146 ++++++++++++++++++------------ include/msgpack/unpack_template.h | 103 ++++++++++++++------- 4 files changed, 175 insertions(+), 136 deletions(-) diff --git a/include/msgpack/pack.hpp b/include/msgpack/pack.hpp index 2e247719..e333d5ab 100644 --- a/include/msgpack/pack.hpp +++ b/include/msgpack/pack.hpp @@ -18,9 +18,11 @@ #ifndef MSGPACK_PACK_HPP #define MSGPACK_PACK_HPP -#include "pack_define.h" #include -#include +#include +#include + +#include "sysdep.h" namespace msgpack { @@ -30,7 +32,6 @@ class packer { public: packer(Stream* s); packer(Stream& s); - ~packer(); public: template @@ -169,9 +170,6 @@ inline packer::packer(Stream* s) : m_stream(*s) { } template inline packer::packer(Stream& s) : m_stream(s) { } -template -inline packer::~packer() { } - template inline packer& packer::pack_uint8(uint8_t d) diff --git a/include/msgpack/sysdep.h b/include/msgpack/sysdep.h index 7756bf59..0613c423 100644 --- a/include/msgpack/sysdep.h +++ b/include/msgpack/sysdep.h @@ -132,53 +132,27 @@ typedef unsigned int _msgpack_atomic_counter_t; ((((uint64_t)x) >> 56) ) ) #endif -#define _msgpack_load16(cast, from) ((cast)( \ - (((uint16_t)((uint8_t*)(from))[0]) << 8) | \ - (((uint16_t)((uint8_t*)(from))[1]) ) )) - -#define _msgpack_load32(cast, from) ((cast)( \ - (((uint32_t)((uint8_t*)(from))[0]) << 24) | \ - (((uint32_t)((uint8_t*)(from))[1]) << 16) | \ - (((uint32_t)((uint8_t*)(from))[2]) << 8) | \ - (((uint32_t)((uint8_t*)(from))[3]) ) )) - -#define _msgpack_load64(cast, from) ((cast)( \ - (((uint64_t)((uint8_t*)(from))[0]) << 56) | \ - (((uint64_t)((uint8_t*)(from))[1]) << 48) | \ - (((uint64_t)((uint8_t*)(from))[2]) << 40) | \ - (((uint64_t)((uint8_t*)(from))[3]) << 32) | \ - (((uint64_t)((uint8_t*)(from))[4]) << 24) | \ - (((uint64_t)((uint8_t*)(from))[5]) << 16) | \ - (((uint64_t)((uint8_t*)(from))[6]) << 8) | \ - (((uint64_t)((uint8_t*)(from))[7]) ) )) - #else /* __LITTLE_ENDIAN__ */ #define _msgpack_be16(x) (x) #define _msgpack_be32(x) (x) #define _msgpack_be64(x) (x) -#define _msgpack_load16(cast, from) ((cast)( \ - (((uint16_t)((uint8_t*)from)[0]) << 8) | \ - (((uint16_t)((uint8_t*)from)[1]) ) )) - -#define _msgpack_load32(cast, from) ((cast)( \ - (((uint32_t)((uint8_t*)from)[0]) << 24) | \ - (((uint32_t)((uint8_t*)from)[1]) << 16) | \ - (((uint32_t)((uint8_t*)from)[2]) << 8) | \ - (((uint32_t)((uint8_t*)from)[3]) ) )) - -#define _msgpack_load64(cast, from) ((cast)( \ - (((uint64_t)((uint8_t*)from)[0]) << 56) | \ - (((uint64_t)((uint8_t*)from)[1]) << 48) | \ - (((uint64_t)((uint8_t*)from)[2]) << 40) | \ - (((uint64_t)((uint8_t*)from)[3]) << 32) | \ - (((uint64_t)((uint8_t*)from)[4]) << 24) | \ - (((uint64_t)((uint8_t*)from)[5]) << 16) | \ - (((uint64_t)((uint8_t*)from)[6]) << 8) | \ - (((uint64_t)((uint8_t*)from)[7]) ) )) #endif +#define _msgpack_load16(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = _msgpack_be16(*(to)); \ + } while (0); + +#define _msgpack_load32(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = _msgpack_be32(*(to)); \ + } while (0); +#define _msgpack_load64(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = _msgpack_be64(*(to)); \ + } while (0); #define _msgpack_store16(to, num) \ do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index a82d2238..735515c5 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -25,7 +25,7 @@ #include #include - +#include @@ -209,42 +209,37 @@ struct fix_tag { }; template -inline unsigned int load(const char* n, typename msgpack::enable_if::type* = nullptr) { - return static_cast(*reinterpret_cast(n)) & 0x0f; +struct value { + typedef T type; +}; +template <> +struct value { + typedef unsigned int type; +}; + +template +inline void load(unsigned int& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + dst = static_cast(*reinterpret_cast(n)) & 0x0f; } template -inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { - return static_cast(*reinterpret_cast(n)); +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + dst = static_cast(*reinterpret_cast(n)); } template -inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { - return static_cast( - (static_cast(reinterpret_cast(n)[0]) << 8) | - (static_cast(reinterpret_cast(n)[1]) )); +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + _msgpack_load16(T, n, &dst); } template -inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { - return static_cast( - (static_cast(reinterpret_cast(n)[0]) << 24) | - (static_cast(reinterpret_cast(n)[1]) << 16) | - (static_cast(reinterpret_cast(n)[2]) << 8) | - (static_cast(reinterpret_cast(n)[3]) )); +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + _msgpack_load32(T, n, &dst); } template -inline T load(const char* n, typename msgpack::enable_if::type* = nullptr) { - return static_cast( - (static_cast(reinterpret_cast(n)[0]) << 56) | - (static_cast(reinterpret_cast(n)[1]) << 48) | - (static_cast(reinterpret_cast(n)[2]) << 40) | - (static_cast(reinterpret_cast(n)[3]) << 32) | - (static_cast(reinterpret_cast(n)[4]) << 24) | - (static_cast(reinterpret_cast(n)[5]) << 16) | - (static_cast(reinterpret_cast(n)[6]) << 8) | - (static_cast(reinterpret_cast(n)[7]) )); +inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + _msgpack_load64(T, n, &dst); } class context { @@ -414,14 +409,14 @@ public: //case CS_ case CS_FLOAT: { union { uint32_t i; float f; } mem; - mem.i = load(n); + load(mem.i, n); unpack_float(mem.f, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_DOUBLE: { union { uint64_t i; double f; } mem; - mem.i = load(n); + load(mem.i, n); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); @@ -431,47 +426,65 @@ public: if (ret != 0) return ret; } break; case CS_UINT_8: { - unpack_uint8(load(n), obj); + uint8_t tmp; + load(tmp, n); + unpack_uint8(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_16: { - unpack_uint16(load(n), obj); + uint16_t tmp; + load(tmp, n); + unpack_uint16(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_32: { - unpack_uint32(load(n), obj); + uint32_t tmp; + load(tmp, n); + unpack_uint32(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_UINT_64: { - unpack_uint64(load(n), obj); + uint64_t tmp; + load(tmp, n); + unpack_uint64(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_8: { - unpack_int8(load(n), obj); + int8_t tmp; + load(tmp, n); + unpack_int8(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_16: { - unpack_int16(load(n), obj); + int16_t tmp; + load(tmp, n); + unpack_int16(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_32: { - unpack_int32(load(n), obj); + int32_t tmp; + load(tmp, n); + unpack_int32(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case CS_INT_64: { - unpack_int64(load(n), obj); + int64_t tmp; + load(tmp, n); + unpack_int64(tmp, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; - case CS_STR_8: - trail_ = load(n); + case CS_STR_8: { + uint8_t tmp; + load(tmp, n); + trail_ = tmp; if(trail_ == 0) { unpack_str(user_, data, n, trail_, obj); int ret = push_proc(obj, off); @@ -481,9 +494,11 @@ public: cs_ = ACS_STR_VALUE; fixed_trail_again = true; } - break; - case CS_BIN_8: - trail_ = load(n); + } break; + case CS_BIN_8: { + uint8_t tmp; + load(tmp, n); + trail_ = tmp; if(trail_ == 0) { unpack_bin(user_, data, n, trail_, obj); int ret = push_proc(obj, off); @@ -493,9 +508,11 @@ public: cs_ = ACS_BIN_VALUE; fixed_trail_again = true; } - break; - case CS_STR_16: - trail_ = load(n); + } break; + case CS_STR_16: { + uint16_t tmp; + load(tmp, n); + trail_ = tmp; if(trail_ == 0) { unpack_str(user_, data, n, trail_, obj); int ret = push_proc(obj, off); @@ -505,9 +522,11 @@ public: cs_ = ACS_STR_VALUE; fixed_trail_again = true; } - break; - case CS_BIN_16: - trail_ = load(n); + } break; + case CS_BIN_16: { + uint16_t tmp; + load(tmp, n); + trail_ = tmp; if(trail_ == 0) { unpack_bin(user_, data, n, trail_, obj); int ret = push_proc(obj, off); @@ -517,9 +536,9 @@ public: cs_ = ACS_BIN_VALUE; fixed_trail_again = true; } - break; + } break; case CS_STR_32: - trail_ = load(n); + load(trail_, n); if(trail_ == 0) { unpack_str(user_, data, n, trail_, obj); int ret = push_proc(obj, off); @@ -531,7 +550,7 @@ public: } break; case CS_BIN_32: - trail_ = load(n); + load(trail_, n); if(trail_ == 0) { unpack_bin(user_, data, n, trail_, obj); int ret = push_proc(obj, off); @@ -599,19 +618,26 @@ private: object& obj, const char* load_pos, size_t& off) { - if(top_ < MSGPACK_EMBED_STACK_SIZE /* FIXME */ - && f(user_, load(load_pos), stack_[top_].obj())) { - if(load(load_pos) == 0) { - obj = stack_[top_].obj(); - int ret = push_proc(obj, off); - if (ret != 0) return ret; + if(top_ < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { + typename value::type tmp; + load(tmp, load_pos); + if (f(user_, tmp, stack_[top_].obj())) { + if(tmp == 0) { + obj = stack_[top_].obj(); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + stack_[top_].set_container_type(container_type); + stack_[top_].set_count(tmp); + ++top_; + cs_ = CS_HEADER; + ++current_; + } } else { - stack_[top_].set_container_type(container_type); - stack_[top_].set_count(load(load_pos)); - ++top_; - cs_ = CS_HEADER; - ++current_; + off = current_ - start_; + return -1; } } else { diff --git a/include/msgpack/unpack_template.h b/include/msgpack/unpack_template.h index f84e9ac6..813021e4 100644 --- a/include/msgpack/unpack_template.h +++ b/include/msgpack/unpack_template.h @@ -260,11 +260,11 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c //case CS_ case CS_FLOAT: { union { uint32_t i; float f; } mem; - mem.i = _msgpack_load32(uint32_t,n); + _msgpack_load32(uint32_t, n, &mem.i); push_fixed_value(_float, mem.f); } case CS_DOUBLE: { union { uint64_t i; double f; } mem; - mem.i = _msgpack_load64(uint64_t,n); + _msgpack_load64(uint64_t, n, &mem.i); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); @@ -272,21 +272,38 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c push_fixed_value(_double, mem.f); } case CS_UINT_8: push_fixed_value(_uint8, *(uint8_t*)n); - case CS_UINT_16: - push_fixed_value(_uint16, _msgpack_load16(uint16_t,n)); - case CS_UINT_32: - push_fixed_value(_uint32, _msgpack_load32(uint32_t,n)); - case CS_UINT_64: - push_fixed_value(_uint64, _msgpack_load64(uint64_t,n)); - + case CS_UINT_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + push_fixed_value(_uint16, tmp); + } + case CS_UINT_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + push_fixed_value(_uint32, tmp); + } + case CS_UINT_64:{ + uint64_t tmp; + _msgpack_load64(uint64_t,n,&tmp); + push_fixed_value(_uint64, tmp); + } case CS_INT_8: push_fixed_value(_int8, *(int8_t*)n); - case CS_INT_16: - push_fixed_value(_int16, _msgpack_load16(int16_t,n)); - case CS_INT_32: - push_fixed_value(_int32, _msgpack_load32(int32_t,n)); - case CS_INT_64: - push_fixed_value(_int64, _msgpack_load64(int64_t,n)); + case CS_INT_16:{ + int16_t tmp; + _msgpack_load16(int16_t,n,&tmp); + push_fixed_value(_int16, tmp); + } + case CS_INT_32:{ + int32_t tmp; + _msgpack_load32(int32_t,n,&tmp); + push_fixed_value(_int32, tmp); + } + case CS_INT_64:{ + int64_t tmp; + _msgpack_load64(int64_t,n,&tmp); + push_fixed_value(_int64, tmp); + } //case CS_ //case CS_ @@ -312,14 +329,26 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero); case CS_BIN_8: again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); - case CS_STR_16: - again_fixed_trail_if_zero(ACS_STR_VALUE, _msgpack_load16(uint16_t,n), _str_zero); - case CS_BIN_16: - again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load16(uint16_t,n), _bin_zero); - case CS_STR_32: - again_fixed_trail_if_zero(ACS_STR_VALUE, _msgpack_load32(uint32_t,n), _str_zero); - case CS_BIN_32: - again_fixed_trail_if_zero(ACS_BIN_VALUE, _msgpack_load32(uint32_t,n), _bin_zero); + case CS_STR_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); + } + case CS_BIN_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); + } + case CS_STR_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); + } + case CS_BIN_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); + } case ACS_STR_VALUE: _str_zero: push_variable_value(_str, data, n, trail); @@ -327,17 +356,29 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c _bin_zero: push_variable_value(_bin, data, n, trail); - case CS_ARRAY_16: - start_container(_array, _msgpack_load16(uint16_t,n), CT_ARRAY_ITEM); - case CS_ARRAY_32: + case CS_ARRAY_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + start_container(_array, tmp, CT_ARRAY_ITEM); + } + case CS_ARRAY_32:{ /* FIXME security guard */ - start_container(_array, _msgpack_load32(uint32_t,n), CT_ARRAY_ITEM); + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + start_container(_array, tmp, CT_ARRAY_ITEM); + } - case CS_MAP_16: - start_container(_map, _msgpack_load16(uint16_t,n), CT_MAP_KEY); - case CS_MAP_32: + case CS_MAP_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + start_container(_map, tmp, CT_MAP_KEY); + } + case CS_MAP_32:{ /* FIXME security guard */ - start_container(_map, _msgpack_load32(uint32_t,n), CT_MAP_KEY); + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + start_container(_map, tmp, CT_MAP_KEY); + } default: goto _failed; From 6a349d0b28c77a542d27283599b0847e54b70e5c Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 26 Jun 2014 11:30:14 +0900 Subject: [PATCH 074/153] Fixed zero size string in the array problem. --- include/msgpack/unpack.hpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 735515c5..68f38906 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -376,8 +376,10 @@ public: int ret = push_proc(obj, off); if (ret != 0) return ret; } - cs_ = ACS_STR_VALUE; - fixed_trail_again = true; + else { + cs_ = ACS_STR_VALUE; + fixed_trail_again = true; + } } else if(0x90 <= selector && selector <= 0x9f) { // FixArray int ret = push_aggregate( From f6a5402194a9a4380337a32125f66f88bddd20eb Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 8 Jul 2014 19:18:43 +0900 Subject: [PATCH 075/153] Supported the C++11 tuple. --- include/msgpack/adaptor/cpp11/tuple.hpp | 121 ++++++++++++++++++ .../adaptor/detail/cpp11_msgpack_tuple.hpp | 26 ++-- include/msgpack/type.hpp | 8 ++ test/msgpack_test.cpp | 20 +++ 4 files changed, 162 insertions(+), 13 deletions(-) create mode 100644 include/msgpack/adaptor/cpp11/tuple.hpp diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp new file mode 100644 index 00000000..b599b4c5 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -0,0 +1,121 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_TUPLE_HPP +#define MSGPACK_CPP11_TUPLE_HPP + +#include + +#include "msgpack/object.hpp" +#include "msgpack/cpp_config.hpp" + +namespace msgpack { + +// --- Pack ( from tuple to packer stream --- +template +struct StdTuplePacker { + static void pack( + packer& o, + const Tuple& v) { + StdTuplePacker::pack(o, v); + o.pack(std::get(v)); + } +}; + +template +struct StdTuplePacker { + static void pack ( + packer& o, + const Tuple& v) { + o.pack(std::get<0>(v)); + } +}; + +template +const packer& operator<< ( + packer& o, + const std::tuple& v) { + o.pack_array(sizeof...(Args)); + StdTuplePacker::pack(o, v); + return o; +} + +// --- Convert from tuple to object --- + +template +struct StdTupleConverter { + static void convert( + object const& o, + Tuple& v) { + StdTupleConverter::convert(o, v); + o.via.array.ptr[N-1].convert(v))>::type>(std::get(v)); + } +}; + +template +struct StdTupleConverter { + static void convert ( + object const& o, + Tuple& v) { + o.via.array.ptr[0].convert(v))>::type>(std::get<0>(v)); + } +}; + +template +std::tuple& operator>> ( + object const& o, + std::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw type_error(); } + StdTupleConverter::convert(o, v); + return v; +} + +// --- Convert from tuple to object with zone --- +template +struct StdTupleToObjectWithZone { + static void convert( + object::with_zone& o, + const Tuple& v) { + StdTupleToObjectWithZone::convert(o, v); + o.via.array.ptr[N-1] = object(std::get(v), o.zone); + } +}; + +template +struct StdTupleToObjectWithZone { + static void convert ( + object::with_zone& o, + const Tuple& v) { + o.via.array.ptr[0] = object(std::get<0>(v), o.zone); + } +}; + +template +inline void operator<< ( + object::with_zone& o, + std::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); + o.via.array.size = sizeof...(Args); + StdTupleToObjectWithZone::convert(o, v); +} + +} // msgpack + +#endif // MSGPACK_CPP11_TUPLE_HPP + diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 98041bb4..9f10ce7a 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -1,7 +1,7 @@ // // MessagePack for C++ static resolution routine // -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -91,17 +91,17 @@ namespace type { // --- Pack ( from tuple to packer stream --- template -struct Packer { +struct MsgpackTuplePacker { static void pack( packer& o, const Tuple& v) { - Packer::pack(o, v); + MsgpackTuplePacker::pack(o, v); o.pack(type::get(v)); } }; template -struct Packer { +struct MsgpackTuplePacker { static void pack ( packer& o, const Tuple& v) { @@ -114,24 +114,24 @@ const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(sizeof...(Args)); - Packer::pack(o, v); + MsgpackTuplePacker::pack(o, v); return o; } // --- Convert from tuple to object --- template -struct Converter { +struct MsgpackTupleConverter { static void convert( object const& o, Tuple& v) { - Converter::convert(o, v); + MsgpackTupleConverter::convert(o, v); o.via.array.ptr[N-1].convert(v))>::type>(type::get(v)); } }; template -struct Converter { +struct MsgpackTupleConverter { static void convert ( object const& o, Tuple& v) { @@ -145,23 +145,23 @@ type::tuple& operator>> ( type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); } - Converter::convert(o, v); + MsgpackTupleConverter::convert(o, v); return v; } // --- Convert from tuple to object with zone --- template -struct TupleToObjectWithZone { +struct MsgpackTupleToObjectWithZone { static void convert( object::with_zone& o, const Tuple& v) { - TupleToObjectWithZone::convert(o, v); + MsgpackTupleToObjectWithZone::convert(o, v); o.via.array.ptr[N-1] = object(type::get(v), o.zone); } }; template -struct TupleToObjectWithZone { +struct MsgpackTupleToObjectWithZone { static void convert ( object::with_zone& o, const Tuple& v) { @@ -176,7 +176,7 @@ inline void operator<< ( o.type = type::ARRAY; o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); o.via.array.size = sizeof...(Args); - TupleToObjectWithZone::convert(o, v); + MsgpackTupleToObjectWithZone::convert(o, v); } } // msgpack diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp index 6a728623..b3da55d4 100644 --- a/include/msgpack/type.hpp +++ b/include/msgpack/type.hpp @@ -1,3 +1,4 @@ +#include "cpp_config.hpp" #include "adaptor/bool.hpp" #include "adaptor/deque.hpp" #include "adaptor/fixint.hpp" @@ -15,3 +16,10 @@ #include "adaptor/define.hpp" #include "adaptor/tr1/unordered_map.hpp" #include "adaptor/tr1/unordered_set.hpp" + +#if !defined(MSGPACK_USE_CPP03) + +#include "adaptor/cpp11/tuple.hpp" + +#endif // !defined(MSGPACK_USE_CPP03) + diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 9673ed91..e3b67ee7 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -740,6 +740,26 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) } #endif +#if !defined(MSGPACK_USE_CPP03) +// C++11 + +TEST(MSGPACK_CPP11, simple_tuple) +{ + msgpack::sbuffer sbuf; + std::tuple val1(true, "kzk", 12.3); + msgpack::pack(sbuf, val1); + msgpack::zone z; + msgpack::object obj; + msgpack::unpack_return ret = + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); + std::tuple val2; + obj.convert(&val2); + EXPECT_EQ(val1, val2); +} + +#endif // !defined(MSGPACK_USE_CPP03) + // User-Defined Structures class TestClass From 212f025f002426c23e4167542638ef5d3c2115dd Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 8 Jul 2014 19:31:02 +0900 Subject: [PATCH 076/153] Supported the C++11's enum class. --- .../msgpack/adaptor/detail/cpp11_define.hpp | 8 ++-- test/msgpack_test.cpp | 45 +++++++++++++++++++ 2 files changed, 50 insertions(+), 3 deletions(-) diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index e43eb86c..15a1df6d 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_CPP11_DEFINE_HPP #define MSGPACK_CPP11_DEFINE_HPP +#include + #define MSGPACK_DEFINE(...) \ template \ void msgpack_pack(Packer& pk) const \ @@ -42,20 +44,20 @@ { \ int tmp; \ o >> tmp; \ - v = static_cast(tmp); \ + v = static_cast(tmp); \ return v; \ } \ template <> \ inline void operator<< (object::with_zone& o, const enum& v) \ { \ - int tmp = static_cast(v); \ + int tmp = static_cast::type>(v); \ o << tmp; \ } \ namespace detail { \ template \ struct packer_serializer { \ static packer& pack(packer& o, const enum& v) { \ - return o << static_cast(v); \ + return o << static_cast::type>(v); \ } \ }; \ } \ diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index e3b67ee7..c3479e63 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -888,6 +888,51 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) EXPECT_EQ(val1.t3, val2.t3); } +#if !defined(MSGPACK_USE_CPP03) + +class TestEnumClassMemberClass +{ +public: + TestEnumClassMemberClass() + : t1(TestEnumClassType::STATE_A), t2(TestEnumClassType::STATE_B), t3(TestEnumClassType::STATE_C) {} + + enum class TestEnumClassType:long { + STATE_INVALID = 0, + STATE_A = 1, + STATE_B = 2, + STATE_C = 3 + }; + TestEnumClassType t1; + TestEnumClassType t2; + TestEnumClassType t3; + + MSGPACK_DEFINE(t1, t2, t3); +}; + +MSGPACK_ADD_ENUM(TestEnumClassMemberClass::TestEnumClassType); + +TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) +{ + TestEnumClassMemberClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::zone z; + msgpack::object obj; + msgpack::unpack_return ret = + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); + TestEnumClassMemberClass val2; + val2.t1 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID; + val2.t2 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID; + val2.t3 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID; + obj.convert(&val2); + EXPECT_EQ(val1.t1, val2.t1); + EXPECT_EQ(val1.t2, val2.t2); + EXPECT_EQ(val1.t3, val2.t3); +} + +#endif // !defined(MSGPACK_USE_CPP03) + class TestUnionMemberClass { public: From 0889e6117e5c990f8e464c0dd74d9126c7ee140a Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 11 Jul 2014 23:37:43 +0900 Subject: [PATCH 077/153] Renamed member variables name. --- erb/cpp03_msgpack_tuple.hpp.erb | 14 +- erb/cpp03_zone.hpp.erb | 122 +- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 7392 ++++++++--------- include/msgpack/detail/cpp03_zone.hpp | 182 +- include/msgpack/detail/cpp11_zone.hpp | 124 +- include/msgpack/sbuffer.hpp | 50 +- include/msgpack/unpack.hpp | 384 +- include/msgpack/vrefbuffer.hpp | 98 +- include/msgpack/zbuffer.hpp | 72 +- 9 files changed, 4219 insertions(+), 4219 deletions(-) diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index da5716b6..43dfe3d5 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -68,11 +68,11 @@ struct tuple_type { <%0.upto(i) {|j|%> template , typename A<%=k%><%}%>> struct tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - tuple_element(tuple, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {} - typename tuple_type>::reference get() { return _x; } - typename tuple_type>::const_reference get() const { return _x; } + tuple_element(tuple, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {} + typename tuple_type>::reference get() { return m_x; } + typename tuple_type>::const_reference get() const { return m_x; } private: - typename tuple_type>::reference _x; + typename tuple_type>::reference m_x; }; <%}%> <%}%> @@ -81,10 +81,10 @@ private: <%0.upto(i) {|j|%> template , typename A<%=k%><%}%>> struct const_tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - const_tuple_element(const tuple, A<%=k%><%}%>>& x) : _x(x.a<%=j%>) {} - typename tuple_type>::const_reference get() const { return _x; } + const_tuple_element(const tuple, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {} + typename tuple_type>::const_reference get() const { return m_x; } private: - typename tuple_type>::const_reference _x; + typename tuple_type>::const_reference m_x; }; <%}%> <%}%> diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index e2228c30..ad9e4fbc 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -37,41 +37,41 @@ namespace msgpack { class zone { struct finalizer { - finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} - void operator()() { func_(data_); } - void (*func_)(void*); - void* data_; + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; }; struct finalizer_array { - finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} void call() { - finalizer* fin = tail_; - for(; fin != array_; --fin) (*(fin-1))(); + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); } ~finalizer_array() { call(); - ::free(array_); + ::free(m_array); } void clear() { call(); - tail_ = array_; + m_tail = m_array; } void push(void (*func)(void* data), void* data) { - finalizer* fin = tail_; + finalizer* fin = m_tail; - if(fin == end_) { + if(fin == m_end) { push_expand(func, data); return; } - fin->func_ = func; - fin->data_ = data; + fin->m_func = func; + fin->m_data = data; - ++tail_; + ++m_tail; } void push_expand(void (*func)(void*), void* data) { - const size_t nused = end_ - array_; + const size_t nused = m_end - m_array; size_t nnext; if(nused == 0) { nnext = (sizeof(finalizer) < 72/2) ? @@ -80,23 +80,23 @@ class zone { nnext = nused * 2; } finalizer* tmp = - static_cast(::realloc(array_, sizeof(finalizer) * nnext)); + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); if(!tmp) { throw std::bad_alloc(); } - array_ = tmp; - end_ = tmp + nnext; - tail_ = tmp + nused; - new (tail_) finalizer(func, data); + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); - ++tail_; + ++m_tail; } - finalizer* tail_; - finalizer* end_; - finalizer* array_; + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; }; struct chunk { - chunk* next_; + chunk* m_next; }; struct chunk_list { chunk_list(size_t chunk_size) @@ -106,16 +106,16 @@ class zone { throw std::bad_alloc(); } - head_ = c; - free_ = chunk_size; - ptr_ = reinterpret_cast(c) + sizeof(chunk); - c->next_ = nullptr; + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; } ~chunk_list() { - chunk* c = head_; + chunk* c = m_head; while(true) { - chunk* n = c->next_; + chunk* n = c->m_next; ::free(c); if(n) { c = n; @@ -126,9 +126,9 @@ class zone { } void clear(size_t chunk_size) { - chunk* c = head_; + chunk* c = m_head; while(true) { - chunk* n = c->next_; + chunk* n = c->m_next; if(n) { ::free(c); c = n; @@ -136,17 +136,17 @@ class zone { break; } } - head_->next_ = nullptr; - free_ = chunk_size; - ptr_ = reinterpret_cast(head_) + sizeof(chunk); + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); } - size_t free_; - char* ptr_; - chunk* head_; + size_t m_free; + char* m_ptr; + chunk* m_head; }; - size_t chunk_size_; - chunk_list chunk_list_; - finalizer_array finalizer_array_; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; public: zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; @@ -214,7 +214,7 @@ inline void zone::destroy(zone* z) ::free(z); } -inline zone::zone(size_t chunk_size) /* throw() */ :chunk_size_(chunk_size), chunk_list_(chunk_size_) +inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } @@ -226,22 +226,22 @@ inline void* zone::allocate_align(size_t size) inline void* zone::allocate_no_align(size_t size) { - if(chunk_list_.free_ < size) { + if(m_chunk_list.m_free < size) { return allocate_expand(size); } - char* ptr = chunk_list_.ptr_; - chunk_list_.free_ -= size; - chunk_list_.ptr_ += size; + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; return ptr; } inline void* zone::allocate_expand(size_t size) { - chunk_list* const cl = &chunk_list_; + chunk_list* const cl = &m_chunk_list; - size_t sz = chunk_size_; + size_t sz = m_chunk_size; while(sz < size) { sz *= 2; @@ -251,30 +251,30 @@ inline void* zone::allocate_expand(size_t size) char* ptr = reinterpret_cast(c) + sizeof(chunk); - c->next_ = cl->head_; - cl->head_ = c; - cl->free_ = sz - size; - cl->ptr_ = ptr + size; + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - finalizer_array_.push(func, data); + m_finalizer_array.push(func, data); } template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - finalizer_array_.push(&zone::object_destructor, obj.get()); + m_finalizer_array.push(&zone::object_destructor, obj.get()); obj.release(); } inline void zone::clear() { - finalizer_array_.clear(); - chunk_list_.clear(chunk_size_); + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); } inline void zone::swap(zone& o) @@ -290,8 +290,8 @@ void zone::object_destructor(void* obj) inline void zone::undo_allocate(size_t size) { - chunk_list_.ptr_ -= size; - chunk_list_.free_ += size; + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; } <%0.upto(GENERATION_LIMIT) {|i|%> @@ -300,7 +300,7 @@ T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -308,7 +308,7 @@ T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) try { return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp index b21fab37..dd520cb1 100644 --- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -68,4816 +68,4816 @@ struct tuple_type { template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : _x(x.a29) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : _x(x.a29) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : _x(x.a30) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a30) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : _x(x.a0) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : _x(x.a1) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : _x(x.a2) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : _x(x.a3) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : _x(x.a4) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : _x(x.a5) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : _x(x.a6) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : _x(x.a7) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : _x(x.a8) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : _x(x.a9) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : _x(x.a10) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : _x(x.a11) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : _x(x.a12) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : _x(x.a13) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : _x(x.a14) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : _x(x.a15) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : _x(x.a16) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : _x(x.a17) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : _x(x.a18) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : _x(x.a19) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : _x(x.a20) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : _x(x.a21) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : _x(x.a22) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : _x(x.a23) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : _x(x.a24) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : _x(x.a25) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : _x(x.a26) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : _x(x.a27) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : _x(x.a28) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : _x(x.a29) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : _x(x.a30) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a30) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; template struct tuple_element, 31> : tuple_type { - tuple_element(tuple& x) : _x(x.a31) {} - typename tuple_type::reference get() { return _x; } - typename tuple_type::const_reference get() const { return _x; } + tuple_element(tuple& x) : m_x(x.a31) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference _x; + typename tuple_type::reference m_x; }; @@ -4886,4288 +4886,4288 @@ private: template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a29) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a29) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a30) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a30) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a0) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a1) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a2) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a3) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a4) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a5) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a6) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a7) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a8) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a9) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a10) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a11) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a12) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a13) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a14) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a15) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a16) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a17) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a18) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a19) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a20) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a21) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a22) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a23) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a24) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a25) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a26) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a27) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a28) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a29) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a30) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a30) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 31> : tuple_type { - const_tuple_element(const tuple& x) : _x(x.a31) {} - typename tuple_type::const_reference get() const { return _x; } + const_tuple_element(const tuple& x) : m_x(x.a31) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference _x; + typename tuple_type::const_reference m_x; }; diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index 4afc8cca..fdd8aa43 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -37,41 +37,41 @@ namespace msgpack { class zone { struct finalizer { - finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} - void operator()() { func_(data_); } - void (*func_)(void*); - void* data_; + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; }; struct finalizer_array { - finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} void call() { - finalizer* fin = tail_; - for(; fin != array_; --fin) (*(fin-1))(); + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); } ~finalizer_array() { call(); - ::free(array_); + ::free(m_array); } void clear() { call(); - tail_ = array_; + m_tail = m_array; } void push(void (*func)(void* data), void* data) { - finalizer* fin = tail_; + finalizer* fin = m_tail; - if(fin == end_) { + if(fin == m_end) { push_expand(func, data); return; } - fin->func_ = func; - fin->data_ = data; + fin->m_func = func; + fin->m_data = data; - ++tail_; + ++m_tail; } void push_expand(void (*func)(void*), void* data) { - const size_t nused = end_ - array_; + const size_t nused = m_end - m_array; size_t nnext; if(nused == 0) { nnext = (sizeof(finalizer) < 72/2) ? @@ -80,23 +80,23 @@ class zone { nnext = nused * 2; } finalizer* tmp = - static_cast(::realloc(array_, sizeof(finalizer) * nnext)); + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); if(!tmp) { throw std::bad_alloc(); } - array_ = tmp; - end_ = tmp + nnext; - tail_ = tmp + nused; - new (tail_) finalizer(func, data); + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); - ++tail_; + ++m_tail; } - finalizer* tail_; - finalizer* end_; - finalizer* array_; + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; }; struct chunk { - chunk* next_; + chunk* m_next; }; struct chunk_list { chunk_list(size_t chunk_size) @@ -106,16 +106,16 @@ class zone { throw std::bad_alloc(); } - head_ = c; - free_ = chunk_size; - ptr_ = reinterpret_cast(c) + sizeof(chunk); - c->next_ = nullptr; + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; } ~chunk_list() { - chunk* c = head_; + chunk* c = m_head; while(true) { - chunk* n = c->next_; + chunk* n = c->m_next; ::free(c); if(n) { c = n; @@ -126,9 +126,9 @@ class zone { } void clear(size_t chunk_size) { - chunk* c = head_; + chunk* c = m_head; while(true) { - chunk* n = c->next_; + chunk* n = c->m_next; if(n) { ::free(c); c = n; @@ -136,17 +136,17 @@ class zone { break; } } - head_->next_ = nullptr; - free_ = chunk_size; - ptr_ = reinterpret_cast(head_) + sizeof(chunk); + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); } - size_t free_; - char* ptr_; - chunk* head_; + size_t m_free; + char* m_ptr; + chunk* m_head; }; - size_t chunk_size_; - chunk_list chunk_list_; - finalizer_array finalizer_array_; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; public: zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; @@ -259,7 +259,7 @@ inline void zone::destroy(zone* z) ::free(z); } -inline zone::zone(size_t chunk_size) /* throw() */ :chunk_size_(chunk_size), chunk_list_(chunk_size_) +inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } @@ -271,22 +271,22 @@ inline void* zone::allocate_align(size_t size) inline void* zone::allocate_no_align(size_t size) { - if(chunk_list_.free_ < size) { + if(m_chunk_list.m_free < size) { return allocate_expand(size); } - char* ptr = chunk_list_.ptr_; - chunk_list_.free_ -= size; - chunk_list_.ptr_ += size; + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; return ptr; } inline void* zone::allocate_expand(size_t size) { - chunk_list* const cl = &chunk_list_; + chunk_list* const cl = &m_chunk_list; - size_t sz = chunk_size_; + size_t sz = m_chunk_size; while(sz < size) { sz *= 2; @@ -296,30 +296,30 @@ inline void* zone::allocate_expand(size_t size) char* ptr = reinterpret_cast(c) + sizeof(chunk); - c->next_ = cl->head_; - cl->head_ = c; - cl->free_ = sz - size; - cl->ptr_ = ptr + size; + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - finalizer_array_.push(func, data); + m_finalizer_array.push(func, data); } template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - finalizer_array_.push(&zone::object_destructor, obj.get()); + m_finalizer_array.push(&zone::object_destructor, obj.get()); obj.release(); } inline void zone::clear() { - finalizer_array_.clear(); - chunk_list_.clear(chunk_size_); + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); } inline void zone::swap(zone& o) @@ -335,8 +335,8 @@ void zone::object_destructor(void* obj) inline void zone::undo_allocate(size_t size) { - chunk_list_.ptr_ -= size; - chunk_list_.free_ += size; + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; } @@ -345,7 +345,7 @@ T* zone::allocate() { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -353,7 +353,7 @@ T* zone::allocate() try { return new (x) T(); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -364,7 +364,7 @@ T* zone::allocate(A1 a1) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -372,7 +372,7 @@ T* zone::allocate(A1 a1) try { return new (x) T(a1); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -383,7 +383,7 @@ T* zone::allocate(A1 a1, A2 a2) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -391,7 +391,7 @@ T* zone::allocate(A1 a1, A2 a2) try { return new (x) T(a1, a2); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -402,7 +402,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -410,7 +410,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3) try { return new (x) T(a1, a2, a3); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -421,7 +421,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -429,7 +429,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) try { return new (x) T(a1, a2, a3, a4); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -440,7 +440,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -448,7 +448,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) try { return new (x) T(a1, a2, a3, a4, a5); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -459,7 +459,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -467,7 +467,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) try { return new (x) T(a1, a2, a3, a4, a5, a6); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -478,7 +478,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -486,7 +486,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) try { return new (x) T(a1, a2, a3, a4, a5, a6, a7); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -497,7 +497,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -505,7 +505,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -516,7 +516,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -524,7 +524,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -535,7 +535,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -543,7 +543,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -554,7 +554,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -562,7 +562,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -573,7 +573,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -581,7 +581,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -592,7 +592,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -600,7 +600,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -611,7 +611,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -619,7 +619,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } @@ -630,7 +630,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -638,7 +638,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, try { return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } diff --git a/include/msgpack/detail/cpp11_zone.hpp b/include/msgpack/detail/cpp11_zone.hpp index db4b0e88..0164b6c0 100644 --- a/include/msgpack/detail/cpp11_zone.hpp +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -37,41 +37,41 @@ namespace msgpack { class zone { private: struct finalizer { - finalizer(void (*func)(void*), void* data):func_(func), data_(data) {} - void operator()() { func_(data_); } - void (*func_)(void*); - void* data_; + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; }; struct finalizer_array { - finalizer_array():tail_(nullptr), end_(nullptr), array_(nullptr) {} + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} void call() { - finalizer* fin = tail_; - for(; fin != array_; --fin) (*(fin-1))(); + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); } ~finalizer_array() { call(); - ::free(array_); + ::free(m_array); } void clear() { call(); - tail_ = array_; + m_tail = m_array; } void push(void (*func)(void* data), void* data) { - finalizer* fin = tail_; + finalizer* fin = m_tail; - if(fin == end_) { + if(fin == m_end) { push_expand(func, data); return; } - fin->func_ = func; - fin->data_ = data; + fin->m_func = func; + fin->m_data = data; - ++tail_; + ++m_tail; } void push_expand(void (*func)(void*), void* data) { - const size_t nused = end_ - array_; + const size_t nused = m_end - m_array; size_t nnext; if(nused == 0) { nnext = (sizeof(finalizer) < 72/2) ? @@ -80,23 +80,23 @@ private: nnext = nused * 2; } finalizer* tmp = - static_cast(::realloc(array_, sizeof(finalizer) * nnext)); + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); if(!tmp) { throw std::bad_alloc(); } - array_ = tmp; - end_ = tmp + nnext; - tail_ = tmp + nused; - new (tail_) finalizer(func, data); + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); - ++tail_; + ++m_tail; } - finalizer* tail_; - finalizer* end_; - finalizer* array_; + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; }; struct chunk { - chunk* next_; + chunk* m_next; }; struct chunk_list { chunk_list(size_t chunk_size) @@ -106,16 +106,16 @@ private: throw std::bad_alloc(); } - head_ = c; - free_ = chunk_size; - ptr_ = reinterpret_cast(c) + sizeof(chunk); - c->next_ = nullptr; + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; } ~chunk_list() { - chunk* c = head_; + chunk* c = m_head; while(true) { - chunk* n = c->next_; + chunk* n = c->m_next; ::free(c); if(n) { c = n; @@ -126,28 +126,28 @@ private: } void clear(size_t chunk_size) { - chunk* c = head_; + chunk* c = m_head; while(true) { - chunk* n = c->next_; + chunk* n = c->m_next; if(n) { ::free(c); c = n; } else { - head_ = c; + m_head = c; break; } } - head_->next_ = nullptr; - free_ = chunk_size; - ptr_ = reinterpret_cast(head_) + sizeof(chunk); + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); } - size_t free_; - char* ptr_; - chunk* head_; + size_t m_free; + char* m_ptr; + chunk* m_head; }; - size_t chunk_size_; - chunk_list chunk_list_; - finalizer_array finalizer_array_; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; public: zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; @@ -214,7 +214,7 @@ inline void zone::destroy(zone* z) ::free(z); } -inline zone::zone(size_t chunk_size) noexcept:chunk_size_(chunk_size), chunk_list_(chunk_size_) +inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } @@ -226,22 +226,22 @@ inline void* zone::allocate_align(size_t size) inline void* zone::allocate_no_align(size_t size) { - if(chunk_list_.free_ < size) { + if(m_chunk_list.m_free < size) { return allocate_expand(size); } - char* ptr = chunk_list_.ptr_; - chunk_list_.free_ -= size; - chunk_list_.ptr_ += size; + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; return ptr; } inline void* zone::allocate_expand(size_t size) { - chunk_list* const cl = &chunk_list_; + chunk_list* const cl = &m_chunk_list; - size_t sz = chunk_size_; + size_t sz = m_chunk_size; while(sz < size) { sz *= 2; @@ -252,30 +252,30 @@ inline void* zone::allocate_expand(size_t size) char* ptr = reinterpret_cast(c) + sizeof(chunk); - c->next_ = cl->head_; - cl->head_ = c; - cl->free_ = sz - size; - cl->ptr_ = ptr + size; + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - finalizer_array_.push(func, data); + m_finalizer_array.push(func, data); } template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - finalizer_array_.push(&zone::object_destructor, obj.get()); + m_finalizer_array.push(&zone::object_destructor, obj.get()); obj.release(); } inline void zone::clear() { - finalizer_array_.clear(); - chunk_list_.clear(chunk_size_); + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); } inline void zone::swap(zone& o) @@ -291,8 +291,8 @@ void zone::object_destructor(void* obj) inline void zone::undo_allocate(size_t size) { - chunk_list_.ptr_ -= size; - chunk_list_.free_ += size; + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; } @@ -301,7 +301,7 @@ T* zone::allocate(Args... args) { void* x = allocate_align(sizeof(T)); try { - finalizer_array_.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destructor, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -309,7 +309,7 @@ T* zone::allocate(Args... args) try { return new (x) T(args...); } catch (...) { - --finalizer_array_.tail_; + --m_finalizer_array.m_tail; undo_allocate(sizeof(T)); throw; } diff --git a/include/msgpack/sbuffer.hpp b/include/msgpack/sbuffer.hpp index 3371bcb1..427603a3 100644 --- a/include/msgpack/sbuffer.hpp +++ b/include/msgpack/sbuffer.hpp @@ -29,13 +29,13 @@ namespace msgpack { class sbuffer { public: - sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):size_(0), alloc_(initsz) + sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):m_size(0), m_alloc(initsz) { if(initsz == 0) { - data_ = nullptr; + m_data = nullptr; } else { - data_ = (char*)::malloc(initsz); - if(!data_) { + m_data = (char*)::malloc(initsz); + if(!m_data) { throw std::bad_alloc(); } } @@ -43,71 +43,71 @@ public: ~sbuffer() { - ::free(data_); + ::free(m_data); } public: void write(const char* buf, size_t len) { - if(alloc_ - size_ < len) { + if(m_alloc - m_size < len) { expand_buffer(len); } - ::memcpy(data_ + size_, buf, len); - size_ += len; + ::memcpy(m_data + m_size, buf, len); + m_size += len; } char* data() { - return data_; + return m_data; } const char* data() const { - return data_; + return m_data; } size_t size() const { - return size_; + return m_size; } char* release() { - char* tmp = data_; - size_ = 0; - data_ = nullptr; - alloc_ = 0; + char* tmp = m_data; + m_size = 0; + m_data = nullptr; + m_alloc = 0; return tmp; } void clear() { - size_ = 0; + m_size = 0; } private: void expand_buffer(size_t len) { - size_t nsize = (alloc_ > 0) ? - alloc_ * 2 : MSGPACK_SBUFFER_INIT_SIZE; + size_t nsize = (m_alloc > 0) ? + m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - while(nsize < size_ + len) { nsize *= 2; } + while(nsize < m_size + len) { nsize *= 2; } - void* tmp = ::realloc(data_, nsize); + void* tmp = ::realloc(m_data, nsize); if(!tmp) { throw std::bad_alloc(); } - data_ = static_cast(tmp); - alloc_ = nsize; + m_data = static_cast(tmp); + m_alloc = nsize; } private: sbuffer(const sbuffer&); private: - size_t size_; - char* data_; - size_t alloc_; + size_t m_size; + char* m_data; + size_t m_alloc; }; diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 68f38906..53066bbc 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -52,14 +52,14 @@ namespace detail { class unpack_user { public: - msgpack::zone const& zone() const { return *zone_; } - msgpack::zone& zone() { return *zone_; } - void set_zone(msgpack::zone& zone) { zone_ = &zone; } - bool referenced() const { return referenced_; } - void set_referenced(bool referenced) { referenced_ = referenced; } + msgpack::zone const& zone() const { return *m_zone; } + msgpack::zone& zone() { return *m_zone; } + void set_zone(msgpack::zone& zone) { m_zone = &zone; } + bool referenced() const { return m_referenced; } + void set_referenced(bool referenced) { m_referenced = referenced; } private: - msgpack::zone* zone_; - bool referenced_; + msgpack::zone* m_zone; + bool m_referenced; }; inline void unpack_uint8(uint8_t d, object& o) @@ -165,21 +165,21 @@ inline void unpack_bin(unpack_user& u, const char* b, const char* p, unsigned in class unpack_stack { public: - object const& obj() const { return obj_; } - object& obj() { return obj_; } - void set_obj(object const& obj) { obj_ = obj; } - size_t count() const { return count_; } - void set_count(size_t count) { count_ = count; } - size_t decl_count() { return --count_; } - unsigned int container_type() const { return container_type_; } - void set_container_type(unsigned int container_type) { container_type_ = container_type; } - object const& map_key() const { return map_key_; } - void set_map_key(object const& map_key) { map_key_ = map_key; } + object const& obj() const { return m_obj; } + object& obj() { return m_obj; } + void set_obj(object const& obj) { m_obj = obj; } + size_t count() const { return m_count; } + void set_count(size_t count) { m_count = count; } + size_t decl_count() { return --m_count; } + unsigned int container_type() const { return m_container_type; } + void set_container_type(unsigned int container_type) { m_container_type = container_type; } + object const& map_key() const { return m_map_key; } + void set_map_key(object const& map_key) { m_map_key = map_key; } private: - object obj_; - size_t count_; - unsigned int container_type_; - object map_key_; + object m_obj; + size_t m_count; + unsigned int m_container_type; + object m_map_key; }; inline void init_count(void* buffer) @@ -244,62 +244,62 @@ inline void load(T& dst, const char* n, typename msgpack::enable_if= off); - start_ = data; - current_ = data + off; - stack_idx_ = 0; + m_start = data; + m_current = data + off; + m_stack_idx = 0; const char* const pe = data + len; const char* n = nullptr; object obj; - if(current_ == pe) { - off = current_ - start_; + if(m_current == pe) { + off = m_current - m_start; return 0; } bool fixed_trail_again = false; do { - if (cs_ == CS_HEADER) { + if (m_cs == CS_HEADER) { fixed_trail_again = false; - int selector = *reinterpret_cast(current_); + int selector = *reinterpret_cast(m_current); if (0) { } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum - unpack_uint8(*reinterpret_cast(current_), obj); + unpack_uint8(*reinterpret_cast(m_current), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum - unpack_int8(*reinterpret_cast(current_), obj); + unpack_int8(*reinterpret_cast(m_current), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else if(0xc0 <= selector && selector <= 0xdf) { // Variable @@ -323,8 +323,8 @@ public: case 0xc4: // bin 8 case 0xc5: // bin 16 case 0xc6: // bin 32 - trail_ = 1 << (static_cast(*current_) & 0x03); - cs_ = next_cs(current_); + m_trail = 1 << (static_cast(*m_current) & 0x03); + m_cs = next_cs(m_current); fixed_trail_again = true; break; @@ -341,8 +341,8 @@ public: case 0xd1: // signed int 16 case 0xd2: // signed int 32 case 0xd3: // signed int 64 - trail_ = 1 << (static_cast(*current_) & 0x03); - cs_ = next_cs(current_); + m_trail = 1 << (static_cast(*m_current) & 0x03); + m_cs = next_cs(m_current); fixed_trail_again = true; break; //case 0xd4: @@ -353,60 +353,60 @@ public: case 0xd9: // str 8 case 0xda: // str 16 case 0xdb: // str 32 - trail_ = 1 << ((static_cast(*current_) & 0x03) - 1); - cs_ = next_cs(current_); + m_trail = 1 << ((static_cast(*m_current) & 0x03) - 1); + m_cs = next_cs(m_current); fixed_trail_again = true; break; case 0xdc: // array 16 case 0xdd: // array 32 case 0xde: // map 16 case 0xdf: // map 32 - trail_ = 2 << (static_cast(*current_) & 0x01); - cs_ = next_cs(current_); + m_trail = 2 << (static_cast(*m_current) & 0x01); + m_cs = next_cs(m_current); fixed_trail_again = true; break; default: - off = current_ - start_; + off = m_current - m_start; return -1; } } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr - trail_ = static_cast(*current_) & 0x1f; - if(trail_ == 0) { - unpack_str(user_, data, n, trail_, obj); + m_trail = static_cast(*m_current) & 0x1f; + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - cs_ = ACS_STR_VALUE; + m_cs = ACS_STR_VALUE; fixed_trail_again = true; } } else if(0x90 <= selector && selector <= 0x9f) { // FixArray int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, obj, current_, off); + unpack_array(), CT_ARRAY_ITEM, obj, m_current, off); if (ret != 0) return ret; } else if(0x80 <= selector && selector <= 0x8f) { // FixMap int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, obj, current_, off); + unpack_map(), CT_MAP_KEY, obj, m_current, off); if (ret != 0) return ret; } else { - off = current_ - start_; + off = m_current - m_start; return -1; } // end CS_HEADER } - if (cs_ != CS_HEADER || fixed_trail_again) { + if (m_cs != CS_HEADER || fixed_trail_again) { if (fixed_trail_again) { - ++current_; + ++m_current; fixed_trail_again = false; } - if((size_t)(pe - current_) < trail_) { - off = current_ - start_; + if((size_t)(pe - m_current) < m_trail) { + off = m_current - m_start; return 0; } - n = current_; - current_ += trail_ - 1; - switch(cs_) { + n = m_current; + m_current += m_trail - 1; + switch(m_cs) { //case CS_ //case CS_ case CS_FLOAT: { @@ -486,90 +486,90 @@ public: case CS_STR_8: { uint8_t tmp; load(tmp, n); - trail_ = tmp; - if(trail_ == 0) { - unpack_str(user_, data, n, trail_, obj); + m_trail = tmp; + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - cs_ = ACS_STR_VALUE; + m_cs = ACS_STR_VALUE; fixed_trail_again = true; } } break; case CS_BIN_8: { uint8_t tmp; load(tmp, n); - trail_ = tmp; - if(trail_ == 0) { - unpack_bin(user_, data, n, trail_, obj); + m_trail = tmp; + if(m_trail == 0) { + unpack_bin(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - cs_ = ACS_BIN_VALUE; + m_cs = ACS_BIN_VALUE; fixed_trail_again = true; } } break; case CS_STR_16: { uint16_t tmp; load(tmp, n); - trail_ = tmp; - if(trail_ == 0) { - unpack_str(user_, data, n, trail_, obj); + m_trail = tmp; + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - cs_ = ACS_STR_VALUE; + m_cs = ACS_STR_VALUE; fixed_trail_again = true; } } break; case CS_BIN_16: { uint16_t tmp; load(tmp, n); - trail_ = tmp; - if(trail_ == 0) { - unpack_bin(user_, data, n, trail_, obj); + m_trail = tmp; + if(m_trail == 0) { + unpack_bin(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - cs_ = ACS_BIN_VALUE; + m_cs = ACS_BIN_VALUE; fixed_trail_again = true; } } break; case CS_STR_32: - load(trail_, n); - if(trail_ == 0) { - unpack_str(user_, data, n, trail_, obj); + load(m_trail, n); + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - cs_ = ACS_STR_VALUE; + m_cs = ACS_STR_VALUE; fixed_trail_again = true; } break; case CS_BIN_32: - load(trail_, n); - if(trail_ == 0) { - unpack_bin(user_, data, n, trail_, obj); + load(m_trail, n); + if(m_trail == 0) { + unpack_bin(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - cs_ = ACS_BIN_VALUE; + m_cs = ACS_BIN_VALUE; fixed_trail_again = true; } break; case ACS_STR_VALUE: { - unpack_str(user_, data, n, trail_, obj); + unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case ACS_BIN_VALUE: { - unpack_bin(user_, data, n, trail_, obj); + unpack_bin(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; @@ -596,13 +596,13 @@ public: if (ret != 0) return ret; } break; default: - off = current_ - start_; + off = m_current - m_start; return -1; } } - } while(current_ != pe); + } while(m_current != pe); - off = current_ - start_; + off = m_current - m_start; return 0; } @@ -620,30 +620,30 @@ private: object& obj, const char* load_pos, size_t& off) { - if(top_ < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { + if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { typename value::type tmp; load(tmp, load_pos); - if (f(user_, tmp, stack_[top_].obj())) { + if (f(m_user, tmp, m_stack[m_top].obj())) { if(tmp == 0) { - obj = stack_[top_].obj(); + obj = m_stack[m_top].obj(); int ret = push_proc(obj, off); if (ret != 0) return ret; } else { - stack_[top_].set_container_type(container_type); - stack_[top_].set_count(tmp); - ++top_; - cs_ = CS_HEADER; - ++current_; + m_stack[m_top].set_container_type(container_type); + m_stack[m_top].set_count(tmp); + ++m_top; + m_cs = CS_HEADER; + ++m_current; } } else { - off = current_ - start_; + off = m_current - m_start; return -1; } } else { - off = current_ - start_; + off = m_current - m_start; return -1; } return 0; @@ -652,18 +652,18 @@ private: int push_item(object& obj) { bool finish = false; while (!finish) { - if(top_ == 0) { + if(m_top == 0) { return 1; } - stack_idx_ = top_ - 1; - unpack_stack* sp = &stack_[stack_idx_]; + m_stack_idx = m_top - 1; + unpack_stack* sp = &m_stack[m_stack_idx]; switch(sp->container_type()) { case CT_ARRAY_ITEM: unpack_array_item(sp->obj(), obj); if(sp->decl_count() == 0) { obj = sp->obj(); - --top_; - /*printf("stack pop %d\n", top_);*/ + --m_top; + /*printf("stack pop %d\n", m_top);*/ } else { finish = true; @@ -678,8 +678,8 @@ private: unpack_map_item(sp->obj(), sp->map_key(), obj); if(sp->decl_count() == 0) { obj = sp->obj(); - --top_; - /*printf("stack pop %d\n", top_);*/ + --m_top; + /*printf("stack pop %d\n", m_top);*/ } else { sp->set_container_type(CT_MAP_KEY); @@ -696,31 +696,31 @@ private: int push_proc(object& obj, size_t& off) { int ret = push_item(obj); if (ret > 0) { - stack_[0].set_obj(obj); - ++current_; + m_stack[0].set_obj(obj); + ++m_current; /*printf("-- finish --\n"); */ - off = current_ - start_; + off = m_current - m_start; } else if (ret < 0) { - off = current_ - start_; + off = m_current - m_start; } else { - cs_ = CS_HEADER; - ++current_; + m_cs = CS_HEADER; + ++m_current; } return ret; } private: - char const* start_; - char const* current_; + char const* m_start; + char const* m_current; - unsigned int trail_; - unpack_user user_; - unsigned int cs_; - unsigned int top_; - unsigned int stack_idx_; - unpack_stack stack_[MSGPACK_EMBED_STACK_SIZE]; + unsigned int m_trail; + unpack_user m_user; + unsigned int m_cs; + unsigned int m_top; + unsigned int m_stack_idx; + unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE]; }; } // detail @@ -853,14 +853,14 @@ private: bool flush_zone(); private: - char* buffer_; - size_t used_; - size_t free_; - size_t off_; - size_t parsed_; - zone* z_; - size_t initial_buffer_size_; - detail::context ctx_; + char* m_buffer; + size_t m_used; + size_t m_free; + size_t m_off; + size_t m_parsed; + zone* m_z; + size_t m_initial_buffer_size; + detail::context m_ctx; private: unpacker(const unpacker&); @@ -909,63 +909,63 @@ inline unpacker::unpacker(size_t initial_buffer_size) throw std::bad_alloc(); } - buffer_ = buffer; - used_ = COUNTER_SIZE; - free_ = initial_buffer_size - used_; - off_ = COUNTER_SIZE; - parsed_ = 0; - initial_buffer_size_ = initial_buffer_size; - z_ = z; + m_buffer = buffer; + m_used = COUNTER_SIZE; + m_free = initial_buffer_size - m_used; + m_off = COUNTER_SIZE; + m_parsed = 0; + m_initial_buffer_size = initial_buffer_size; + m_z = z; - detail::init_count(buffer_); + detail::init_count(m_buffer); - ctx_.init(); - ctx_.user().set_zone(*z_); - ctx_.user().set_referenced(false); + m_ctx.init(); + m_ctx.user().set_zone(*m_z); + m_ctx.user().set_referenced(false); } inline unpacker::~unpacker() { - zone::destroy(z_); - detail::decl_count(buffer_); + zone::destroy(m_z); + detail::decl_count(m_buffer); } inline void unpacker::reserve_buffer(size_t size) { - if(free_ >= size) return; + if(m_free >= size) return; expand_buffer(size); } inline void unpacker::expand_buffer(size_t size) { - if(used_ == off_ && detail::get_count(buffer_) == 1 - && !ctx_.user().referenced()) { + if(m_used == m_off && detail::get_count(m_buffer) == 1 + && !m_ctx.user().referenced()) { // rewind buffer - free_ += used_ - COUNTER_SIZE; - used_ = COUNTER_SIZE; - off_ = COUNTER_SIZE; + m_free += m_used - COUNTER_SIZE; + m_used = COUNTER_SIZE; + m_off = COUNTER_SIZE; - if(free_ >= size) return; + if(m_free >= size) return; } - if(off_ == COUNTER_SIZE) { - size_t next_size = (used_ + free_) * 2; // include COUNTER_SIZE - while(next_size < size + used_) { + if(m_off == COUNTER_SIZE) { + size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE + while(next_size < size + m_used) { next_size *= 2; } - char* tmp = static_cast(::realloc(buffer_, next_size)); + char* tmp = static_cast(::realloc(m_buffer, next_size)); if(!tmp) { throw std::bad_alloc(); } - buffer_ = tmp; - free_ = next_size - used_; + m_buffer = tmp; + m_free = next_size - m_used; } else { - size_t next_size = initial_buffer_size_; // include COUNTER_SIZE - size_t not_parsed = used_ - off_; + size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE + size_t not_parsed = m_used - m_off; while(next_size < size + not_parsed + COUNTER_SIZE) { next_size *= 2; } @@ -977,42 +977,42 @@ inline void unpacker::expand_buffer(size_t size) detail::init_count(tmp); - ::memcpy(tmp+COUNTER_SIZE, buffer_ + off_, not_parsed); + ::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); - if(ctx_.user().referenced()) { + if(m_ctx.user().referenced()) { try { - z_->push_finalizer(&detail::decl_count, buffer_); + m_z->push_finalizer(&detail::decl_count, m_buffer); } catch (...) { ::free(tmp); throw; } - ctx_.user().set_referenced(false); + m_ctx.user().set_referenced(false); } else { - detail::decl_count(buffer_); + detail::decl_count(m_buffer); } - buffer_ = tmp; - used_ = not_parsed + COUNTER_SIZE; - free_ = next_size - used_; - off_ = COUNTER_SIZE; + m_buffer = tmp; + m_used = not_parsed + COUNTER_SIZE; + m_free = next_size - m_used; + m_off = COUNTER_SIZE; } } inline char* unpacker::buffer() { - return buffer_ + used_; + return m_buffer + m_used; } inline size_t unpacker::buffer_capacity() const { - return free_; + return m_free; } inline void unpacker::buffer_consumed(size_t size) { - used_ += size; - free_ -= size; + m_used += size; + m_free -= size; } inline bool unpacker::next(unpacked* result) @@ -1051,17 +1051,17 @@ inline bool unpacker::execute() inline int unpacker::execute_imp() { - size_t off = off_; - int ret = ctx_.execute(buffer_, used_, off_); - if(off_ > off) { - parsed_ += off_ - off; + size_t off = m_off; + int ret = m_ctx.execute(m_buffer, m_used, m_off); + if(m_off > off) { + m_parsed += m_off - off; } return ret; } inline object const& unpacker::data() { - return ctx_.data(); + return m_ctx.data(); } inline zone* unpacker::release_zone() @@ -1075,29 +1075,29 @@ inline zone* unpacker::release_zone() return nullptr; } - zone* old = z_; - z_ = r; - ctx_.user().set_zone(*z_); + zone* old = m_z; + m_z = r; + m_ctx.user().set_zone(*m_z); return old; } inline void unpacker::reset_zone() { - z_->clear(); + m_z->clear(); } inline bool unpacker::flush_zone() { - if(ctx_.user().referenced()) { + if(m_ctx.user().referenced()) { try { - z_->push_finalizer(&detail::decl_count, buffer_); + m_z->push_finalizer(&detail::decl_count, m_buffer); } catch (...) { return false; } - ctx_.user().set_referenced(false); + m_ctx.user().set_referenced(false); - detail::incr_count(buffer_); + detail::incr_count(m_buffer); } return true; @@ -1105,39 +1105,39 @@ inline bool unpacker::flush_zone() inline void unpacker::reset() { - ctx_.init(); + m_ctx.init(); // don't reset referenced flag - parsed_ = 0; + m_parsed = 0; } inline size_t unpacker::message_size() const { - return parsed_ - off_ + used_; + return m_parsed - m_off + m_used; } inline size_t unpacker::parsed_size() const { - return parsed_; + return m_parsed; } inline char* unpacker::nonparsed_buffer() { - return buffer_ + off_; + return m_buffer + m_off; } inline size_t unpacker::nonparsed_size() const { - return used_ - off_; + return m_used - m_off; } inline void unpacker::skip_nonparsed_buffer(size_t size) { - off_ += size; + m_off += size; } inline void unpacker::remove_nonparsed_buffer() { - used_ = off_; + m_used = m_off; } namespace detail { diff --git a/include/msgpack/vrefbuffer.hpp b/include/msgpack/vrefbuffer.hpp index 97afcf38..575bbed4 100644 --- a/include/msgpack/vrefbuffer.hpp +++ b/include/msgpack/vrefbuffer.hpp @@ -57,7 +57,7 @@ private: public: vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) - :ref_size_(ref_size), chunk_size_(chunk_size) + :m_ref_size(ref_size), m_chunk_size(chunk_size) { size_t nfirst = (sizeof(iovec) < 72/2) ? 72 / sizeof(iovec) : 8; @@ -68,16 +68,16 @@ public: throw std::bad_alloc(); } - tail_ = array; - end_ = array + nfirst; - array_ = array; + m_tail = array; + m_end = array + nfirst; + m_array = array; chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); if(!c) { ::free(array); throw std::bad_alloc(); } - inner_buffer* const ib = &inner_buffer_; + inner_buffer* const ib = &m_inner_buffer; ib->free = chunk_size; ib->ptr = reinterpret_cast(c) + sizeof(chunk); @@ -88,7 +88,7 @@ public: ~vrefbuffer() { - chunk* c = inner_buffer_.head; + chunk* c = m_inner_buffer.head; while(true) { chunk* n = c->next; ::free(c); @@ -98,13 +98,13 @@ public: break; } } - ::free(array_); + ::free(m_array); } public: void write(const char* buf, size_t len) { - if(len < ref_size_) { + if(len < m_ref_size) { append_copy(buf, len); } else { append_ref(buf, len); @@ -113,32 +113,32 @@ public: void append_ref(const char* buf, size_t len) { - if(tail_ == end_) { - const size_t nused = tail_ - array_; + if(m_tail == m_end) { + const size_t nused = m_tail - m_array; const size_t nnext = nused * 2; iovec* nvec = static_cast(::realloc( - array_, sizeof(iovec)*nnext)); + m_array, sizeof(iovec)*nnext)); if(!nvec) { throw std::bad_alloc(); } - array_ = nvec; - end_ = nvec + nnext; - tail_ = nvec + nused; + m_array = nvec; + m_end = nvec + nnext; + m_tail = nvec + nused; } - tail_->iov_base = const_cast(buf); - tail_->iov_len = len; - ++tail_; + m_tail->iov_base = const_cast(buf); + m_tail->iov_len = len; + ++m_tail; } void append_copy(const char* buf, size_t len) { - inner_buffer* const ib = &inner_buffer_; + inner_buffer* const ib = &m_inner_buffer; if(ib->free < len) { - size_t sz = chunk_size_; + size_t sz = m_chunk_size; if(sz < len) { sz = len; } @@ -159,11 +159,11 @@ public: ib->free -= len; ib->ptr += len; - if(tail_ != array_ && m == + if(m_tail != m_array && m == static_cast( - const_cast((tail_ - 1)->iov_base) - ) + (tail_ - 1)->iov_len) { - (tail_ - 1)->iov_len += len; + const_cast((m_tail - 1)->iov_base) + ) + (m_tail - 1)->iov_len) { + (m_tail - 1)->iov_len += len; return; } else { append_ref( m, len); @@ -172,17 +172,17 @@ public: const struct iovec* vector() const { - return array_; + return m_array; } size_t vector_size() const { - return tail_ - array_; + return m_tail - m_array; } void migrate(vrefbuffer* to) { - size_t sz = chunk_size_; + size_t sz = m_chunk_size; chunk* empty = static_cast(::malloc(sizeof(chunk) + sz)); if(!empty) { @@ -191,35 +191,35 @@ public: empty->next = nullptr; - const size_t nused = tail_ - array_; - if(to->tail_ + nused < end_) { - const size_t tosize = to->tail_ - to->array_; + const size_t nused = m_tail - m_array; + if(to->m_tail + nused < m_end) { + const size_t tosize = to->m_tail - to->m_array; const size_t reqsize = nused + tosize; - size_t nnext = (to->end_ - to->array_) * 2; + size_t nnext = (to->m_end - to->m_array) * 2; while(nnext < reqsize) { nnext *= 2; } iovec* nvec = static_cast(::realloc( - to->array_, sizeof(iovec)*nnext)); + to->m_array, sizeof(iovec)*nnext)); if(!nvec) { ::free(empty); throw std::bad_alloc(); } - to->array_ = nvec; - to->end_ = nvec + nnext; - to->tail_ = nvec + tosize; + to->m_array = nvec; + to->m_end = nvec + nnext; + to->m_tail = nvec + tosize; } - ::memcpy(to->tail_, array_, sizeof(iovec)*nused); + ::memcpy(to->m_tail, m_array, sizeof(iovec)*nused); - to->tail_ += nused; - tail_ = array_; + to->m_tail += nused; + m_tail = m_array; - inner_buffer* const ib = &inner_buffer_; - inner_buffer* const toib = &to->inner_buffer_; + inner_buffer* const ib = &m_inner_buffer; + inner_buffer* const toib = &to->m_inner_buffer; chunk* last = ib->head; while(last->next) { @@ -241,7 +241,7 @@ public: void clear() { - chunk* c = inner_buffer_.head->next; + chunk* c = m_inner_buffer.head->next; chunk* n; while(c) { n = c->next; @@ -249,27 +249,27 @@ public: c = n; } - inner_buffer* const ib = &inner_buffer_; + inner_buffer* const ib = &m_inner_buffer; c = ib->head; c->next = nullptr; - ib->free = chunk_size_; + ib->free = m_chunk_size; ib->ptr = reinterpret_cast(c) + sizeof(chunk); - tail_ = array_; + m_tail = m_array; } private: vrefbuffer(const vrefbuffer&); private: - iovec* tail_; - iovec* end_; - iovec* array_; + iovec* m_tail; + iovec* m_end; + iovec* m_array; - size_t ref_size_; - size_t chunk_size_; + size_t m_ref_size; + size_t m_chunk_size; - inner_buffer inner_buffer_; + inner_buffer m_inner_buffer; }; diff --git a/include/msgpack/zbuffer.hpp b/include/msgpack/zbuffer.hpp index da84edae..5606d372 100644 --- a/include/msgpack/zbuffer.hpp +++ b/include/msgpack/zbuffer.hpp @@ -36,49 +36,49 @@ class zbuffer { public: zbuffer(int level = Z_DEFAULT_COMPRESSION, size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE) - : data_(nullptr), init_size_(init_size) + : m_data(nullptr), m_init_size(init_size) { - stream_.zalloc = Z_NULL; - stream_.zfree = Z_NULL; - stream_.opaque = Z_NULL; - stream_.next_out = Z_NULL; - stream_.avail_out = 0; - if(deflateInit(&stream_, level) != Z_OK) { + m_stream.zalloc = Z_NULL; + m_stream.zfree = Z_NULL; + m_stream.opaque = Z_NULL; + m_stream.next_out = Z_NULL; + m_stream.avail_out = 0; + if(deflateInit(&m_stream, level) != Z_OK) { throw std::bad_alloc(); } } ~zbuffer() { - deflateEnd(&stream_); - ::free(data_); + deflateEnd(&m_stream); + ::free(m_data); } public: void write(const char* buf, size_t len) { - stream_.next_in = reinterpret_cast(const_cast(buf)); - stream_.avail_in = len; + m_stream.next_in = reinterpret_cast(const_cast(buf)); + m_stream.avail_in = len; do { - if(stream_.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { + if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { if(!expand()) { throw std::bad_alloc(); } } - if(deflate(&stream_, Z_NO_FLUSH) != Z_OK) { + if(deflate(&m_stream, Z_NO_FLUSH) != Z_OK) { throw std::bad_alloc(); } - } while(stream_.avail_in > 0); + } while(m_stream.avail_in > 0); } char* flush() { while(true) { - switch(deflate(&stream_, Z_FINISH)) { + switch(deflate(&m_stream, Z_FINISH)) { case Z_STREAM_END: - return data_; + return m_data; case Z_OK: if(!expand()) { throw std::bad_alloc(); @@ -92,22 +92,22 @@ public: char* data() { - return data_; + return m_data; } const char* data() const { - return data_; + return m_data; } size_t size() const { - return reinterpret_cast(stream_.next_out) - data_; + return reinterpret_cast(m_stream.next_out) - m_data; } void reset() { - if(deflateReset(&stream_) != Z_OK) { + if(deflateReset(&m_stream) != Z_OK) { throw std::bad_alloc(); } reset_buffer(); @@ -115,34 +115,34 @@ public: void reset_buffer() { - stream_.avail_out += reinterpret_cast(stream_.next_out) - data_; - stream_.next_out = reinterpret_cast(data_); + m_stream.avail_out += reinterpret_cast(m_stream.next_out) - m_data; + m_stream.next_out = reinterpret_cast(m_data); } char* release_buffer() { - char* tmp = data_; - data_ = nullptr; - stream_.next_out = nullptr; - stream_.avail_out = 0; + char* tmp = m_data; + m_data = nullptr; + m_stream.next_out = nullptr; + m_stream.avail_out = 0; return tmp; } private: bool expand() { - size_t used = reinterpret_cast(stream_.next_out) - data_; - size_t csize = used + stream_.avail_out; - size_t nsize = (csize == 0) ? init_size_ : csize * 2; + size_t used = reinterpret_cast(m_stream.next_out) - m_data; + size_t csize = used + m_stream.avail_out; + size_t nsize = (csize == 0) ? m_init_size : csize * 2; - char* tmp = static_cast(::realloc(data_, nsize)); + char* tmp = static_cast(::realloc(m_data, nsize)); if(tmp == nullptr) { return false; } - data_ = tmp; - stream_.next_out = reinterpret_cast(tmp + used); - stream_.avail_out = nsize - used; + m_data = tmp; + m_stream.next_out = reinterpret_cast(tmp + used); + m_stream.avail_out = nsize - used; return true; } @@ -150,9 +150,9 @@ private: zbuffer(const zbuffer&); private: - z_stream stream_; - char* data_; - size_t init_size_; + z_stream m_stream; + char* m_data; + size_t m_init_size; }; From b0df21295c5ce79de5c2e235ce4f42ace105a78c Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 12 Jul 2014 00:17:31 +0900 Subject: [PATCH 078/153] Untabified. Adjust line break positions. --- erb/cpp03_define.hpp.erb | 132 +- erb/cpp03_msgpack_tuple.hpp.erb | 152 +- erb/cpp03_zone.hpp.erb | 406 +- example/custom.cc | 58 +- example/protocol.cc | 116 +- example/simple.c | 46 +- example/simple.cc | 40 +- example/speed_test.cc | 94 +- example/speed_test_nested_array.cc | 122 +- example/speed_test_uint32_array.c | 40 +- example/speed_test_uint64_array.c | 42 +- example/stream.cc | 158 +- include/msgpack/adaptor/bool.hpp | 18 +- include/msgpack/adaptor/cpp11/tuple.hpp | 100 +- include/msgpack/adaptor/deque.hpp | 62 +- .../msgpack/adaptor/detail/cpp03_define.hpp | 6208 +++---- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 14784 ++++++++-------- .../msgpack/adaptor/detail/cpp11_define.hpp | 210 +- .../adaptor/detail/cpp11_msgpack_tuple.hpp | 202 +- include/msgpack/adaptor/fixint.hpp | 74 +- include/msgpack/adaptor/float.hpp | 72 +- include/msgpack/adaptor/int.hpp | 238 +- include/msgpack/adaptor/list.hpp | 62 +- include/msgpack/adaptor/map.hpp | 228 +- include/msgpack/adaptor/nil.hpp | 16 +- include/msgpack/adaptor/pair.hpp | 30 +- include/msgpack/adaptor/raw.hpp | 68 +- include/msgpack/adaptor/set.hpp | 120 +- include/msgpack/adaptor/string.hpp | 46 +- include/msgpack/adaptor/tr1/unordered_map.hpp | 134 +- include/msgpack/adaptor/tr1/unordered_set.hpp | 120 +- include/msgpack/adaptor/vector.hpp | 70 +- include/msgpack/cpp_config.hpp | 30 +- include/msgpack/detail/cpp03_zone.hpp | 916 +- include/msgpack/detail/cpp11_zone.hpp | 386 +- include/msgpack/fbuffer.h | 2 +- include/msgpack/fbuffer.hpp | 28 +- include/msgpack/object.h | 58 +- include/msgpack/object.hpp | 540 +- include/msgpack/pack.h | 26 +- include/msgpack/pack.hpp | 1006 +- include/msgpack/pack_template.h | 742 +- include/msgpack/sbuffer.h | 58 +- include/msgpack/sbuffer.hpp | 132 +- include/msgpack/unpack.h | 72 +- include/msgpack/unpack.hpp | 1672 +- include/msgpack/unpack_define.h | 78 +- include/msgpack/unpack_template.h | 640 +- include/msgpack/version.hpp | 6 +- include/msgpack/vrefbuffer.h | 64 +- include/msgpack/vrefbuffer.hpp | 364 +- include/msgpack/zbuffer.h | 154 +- include/msgpack/zbuffer.hpp | 198 +- include/msgpack/zone.h | 74 +- include/msgpack/zone.hpp | 18 +- src/gcc_atomic.hpp | 4 +- src/objectc.c | 350 +- src/unpack.c | 462 +- src/version.c | 6 +- src/vrefbuffer.c | 280 +- src/zone.c | 226 +- test/buffer.cc | 144 +- test/cases.cc | 46 +- test/convert.cc | 72 +- test/fixint.cc | 58 +- test/fixint_c.cc | 42 +- test/msgpack_tuple.cc | 132 +- test/msgpackc_test.cpp | 8 +- test/object.cc | 136 +- test/pack_unpack.cc | 126 +- test/pack_unpack_c.cc | 78 +- test/streaming.cc | 286 +- test/streaming_c.cc | 186 +- test/version.cc | 12 +- test/zone.cc | 64 +- 75 files changed, 17125 insertions(+), 17125 deletions(-) diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index d5268f8e..fa27ecd6 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -19,20 +19,20 @@ #define MSGPACK_CPP03_DEFINE_HPP #define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object const& o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - }\ - template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ - } + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object const& o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } // MSGPACK_ADD_ENUM must be used in the global namespace. #define MSGPACK_ADD_ENUM(enum) \ @@ -71,72 +71,72 @@ struct define; template <> struct define<> { - typedef define<> value_type; - typedef tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(0); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = nullptr; - o->via.array.size = 0; - } + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = nullptr; + o->via.array.size = 0; + } }; <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> struct define, A<%=j%><%}%>> { - typedef define, A<%=j%><%}%>> value_type; - typedef tuple, A<%=j%><%}%>> tuple_type; - define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) : - a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(<%=i+1%>); - <%0.upto(i) {|j|%> - pk.pack(a<%=j%>);<%}%> - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default:<%(i).downto(0) {|j|%> - case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%> - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*<%=i+1%>)); - o->via.array.size = <%=i+1%>; - <%0.upto(i) {|j|%> - o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%> - } - <%0.upto(i) {|j|%> - A<%=j%>& a<%=j%>;<%}%> + typedef define, A<%=j%><%}%>> value_type; + typedef tuple, A<%=j%><%}%>> tuple_type; + define(A0& _a0<%1.upto(i) {|j|%>, A<%=j%>& _a<%=j%><%}%>) : + a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(<%=i+1%>); + <%0.upto(i) {|j|%> + pk.pack(a<%=j%>);<%}%> + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default:<%(i).downto(0) {|j|%> + case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%> + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*<%=i+1%>)); + o->via.array.size = <%=i+1%>; + <%0.upto(i) {|j|%> + o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%> + } + <%0.upto(i) {|j|%> + A<%=j%>& a<%=j%>;<%}%> }; <%}%> inline define<> make_define() { - return define<>(); + return define<>(); } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, A<%=j%>& a<%=j%><%}%>) { - return define, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); + return define, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); } <%}%> diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index 43dfe3d5..c0c73c61 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -39,40 +39,40 @@ struct const_tuple_element; template struct tuple_type { - typedef T type; - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; + typedef T type; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; }; template struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef T& transparent_reference; + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& transparent_reference; }; template struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; }; <%0.upto(GENERATION_LIMIT) {|i|%> <%0.upto(i) {|j|%> template , typename A<%=k%><%}%>> struct tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - tuple_element(tuple, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {} - typename tuple_type>::reference get() { return m_x; } - typename tuple_type>::const_reference get() const { return m_x; } + tuple_element(tuple, A<%=k%> <%}%>>& x) : m_x(x.a<%=j%>) {} + typename tuple_type>::reference get() { return m_x; } + typename tuple_type>::const_reference get() const { return m_x; } private: - typename tuple_type>::reference m_x; + typename tuple_type>::reference m_x; }; <%}%> <%}%> @@ -81,34 +81,34 @@ private: <%0.upto(i) {|j|%> template , typename A<%=k%><%}%>> struct const_tuple_element, A<%=k%><%}%>>, <%=j%>> : tuple_type> { - const_tuple_element(const tuple, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {} - typename tuple_type>::const_reference get() const { return m_x; } + const_tuple_element(const tuple, A<%=k%><%}%>>& x) : m_x(x.a<%=j%>) {} + typename tuple_type>::const_reference get() const { return m_x; } private: - typename tuple_type>::const_reference m_x; + typename tuple_type>::const_reference m_x; }; <%}%> <%}%> template <> struct tuple<> { - tuple() {} - tuple(object const& o) { o.convert(*this); } - typedef tuple<> value_type; + tuple() {} + tuple(object const& o) { o.convert(*this); } + typedef tuple<> value_type; }; <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> struct tuple, A<%=j%><%}%>> { - typedef tuple, A<%=j%><%}%>> value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : - a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - <%0.upto(i) {|j|%> - A<%=j%> a<%=j%>;<%}%> + typedef tuple, A<%=j%><%}%>> value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference _a<%=j%><%}%>) : + a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + <%0.upto(i) {|j|%> + A<%=j%> a<%=j%>;<%}%> }; template , typename A<%=j%><%}%>> @@ -121,73 +121,73 @@ inline typename type::const_tuple_element, A<%= inline tuple<> make_tuple() { - return tuple<>(); + return tuple<>(); } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>) { - return tuple, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); + return tuple, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); } <%}%> } // namespace type inline type::tuple<>& operator>> ( - object const& o, - type::tuple<>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - return v; + object const& o, + type::tuple<>& v) { + if(o.type != type::ARRAY) { throw type_error(); } + return v; } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> type::tuple, A<%=j%><%}%>>& operator>> ( - object const& o, - type::tuple, A<%=j%><%}%>>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < <%=i+1%>) { throw type_error(); } - <%0.upto(i) {|j|%> - o.via.array.ptr[<%=j%>].convert>::type>(v.template get<<%=j%>>());<%}%> - return v; + object const& o, + type::tuple, A<%=j%><%}%>>& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < <%=i+1%>) { throw type_error(); } + <%0.upto(i) {|j|%> + o.via.array.ptr[<%=j%>].convert>::type>(v.template get<<%=j%>>());<%}%> + return v; } <%}%> template const packer& operator<< ( - packer& o, - const type::tuple<>& v) { - o.pack_array(0); - return o; + packer& o, + const type::tuple<>& v) { + o.pack_array(0); + return o; } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> const packer& operator<< ( - packer& o, - const type::tuple, A<%=j%><%}%>>& v) { - o.pack_array(<%=i+1%>); - <%0.upto(i) {|j|%> - o.pack(v.template get<<%=j%>>());<%}%> - return o; + packer& o, + const type::tuple, A<%=j%><%}%>>& v) { + o.pack_array(<%=i+1%>); + <%0.upto(i) {|j|%> + o.pack(v.template get<<%=j%>>());<%}%> + return o; } <%}%> inline void operator<< ( - object::with_zone& o, - const type::tuple<>& v) { - o.type = type::ARRAY; - o.via.array.ptr = nullptr; - o.via.array.size = 0; + object::with_zone& o, + const type::tuple<>& v) { + o.type = type::ARRAY; + o.via.array.ptr = nullptr; + o.via.array.size = 0; } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> inline void operator<< ( - object::with_zone& o, - const type::tuple, A<%=j%><%}%>>& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*<%=i+1%>)); - o.via.array.size = <%=i+1%>; - <%0.upto(i) {|j|%> - o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%> + object::with_zone& o, + const type::tuple, A<%=j%><%}%>>& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*<%=i+1%>)); + o.via.array.size = <%=i+1%>; + <%0.upto(i) {|j|%> + o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%> } <%}%> @@ -200,11 +200,11 @@ inline void operator<< ( //<%0.upto(GENERATION_LIMIT) {|i|%> //template , typename A<%=j%><%}%>> //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple, A<%=j%><%}%>>& v) { -// return o << "[" -// <%0.upto(i) {|j|%> -// <<<%if j != 0 then%> ", " <<<%end%> v.template get<<%=j%>>()<%}%> -// << "]"; +// const msgpack::type::tuple, A<%=j%><%}%>>& v) { +// return o << "[" +// <%0.upto(i) {|j|%> +// <<<%if j != 0 then%> ", " <<<%end%> v.template get<<%=j%>>()<%}%> +// << "]"; //} //<%}%> diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index ad9e4fbc..9fe142e8 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -3,17 +3,17 @@ // // Copyright (C) 2008-2010 FURUHASHI Sadayuki // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at // -// http://www.apache.org/licenses/LICENSE-2.0 +// http://www.apache.org/licenses/LICENSE-2.0 // -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. // #ifndef MSGPACK_CPP03_ZONE_HPP #define MSGPACK_CPP03_ZONE_HPP @@ -36,182 +36,182 @@ namespace msgpack { class zone { - struct finalizer { - finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} - void operator()() { m_func(m_data); } - void (*m_func)(void*); - void* m_data; - }; - struct finalizer_array { - finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} - void call() { - finalizer* fin = m_tail; - for(; fin != m_array; --fin) (*(fin-1))(); - } - ~finalizer_array() { - call(); - ::free(m_array); - } - void clear() { - call(); - m_tail = m_array; - } - void push(void (*func)(void* data), void* data) - { - finalizer* fin = m_tail; + struct finalizer { + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; + }; + struct finalizer_array { + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} + void call() { + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(m_array); + } + void clear() { + call(); + m_tail = m_array; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = m_tail; - if(fin == m_end) { - push_expand(func, data); - return; - } + if(fin == m_end) { + push_expand(func, data); + return; + } - fin->m_func = func; - fin->m_data = data; + fin->m_func = func; + fin->m_data = data; - ++m_tail; - } - void push_expand(void (*func)(void*), void* data) { - const size_t nused = m_end - m_array; - size_t nnext; - if(nused == 0) { - nnext = (sizeof(finalizer) < 72/2) ? - 72 / sizeof(finalizer) : 8; - } else { - nnext = nused * 2; - } - finalizer* tmp = - static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); - if(!tmp) { - throw std::bad_alloc(); - } - m_array = tmp; - m_end = tmp + nnext; - m_tail = tmp + nused; - new (m_tail) finalizer(func, data); + ++m_tail; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = m_end - m_array; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); - ++m_tail; - } - finalizer* m_tail; - finalizer* m_end; - finalizer* m_array; - }; - struct chunk { - chunk* m_next; - }; - struct chunk_list { - chunk_list(size_t chunk_size) - { - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - throw std::bad_alloc(); - } + ++m_tail; + } + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; + }; + struct chunk { + chunk* m_next; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } - m_head = c; - m_free = chunk_size; - m_ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = nullptr; - } - ~chunk_list() - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - ::free(c); - if(n) { - c = n; - } else { - break; - } - } - } - void clear(size_t chunk_size) - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - if(n) { - ::free(c); - c = n; - } else { - break; - } - } - m_head->m_next = nullptr; - m_free = chunk_size; - m_ptr = reinterpret_cast(m_head) + sizeof(chunk); - } - size_t m_free; - char* m_ptr; - chunk* m_head; - }; - size_t m_chunk_size; - chunk_list m_chunk_list; - finalizer_array m_finalizer_array; + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; + } + ~chunk_list() + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + ::free(c); + if(n) { + c = n; + } else { + break; + } + } + } + void clear(size_t chunk_size) + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); + } + size_t m_free; + char* m_ptr; + chunk* m_head; + }; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; public: - static zone* create(size_t chunk_size); - static void destroy(zone* zone); - void* allocate_align(size_t size); - void* allocate_no_align(size_t size); + static zone* create(size_t chunk_size); + static void destroy(zone* zone); + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); - void push_finalizer(void (*func)(void*), void* data); + void push_finalizer(void (*func)(void*), void* data); - template - void push_finalizer(msgpack::unique_ptr obj); + template + void push_finalizer(msgpack::unique_ptr obj); - void clear(); + void clear(); - void swap(zone& o); - static void* operator new(std::size_t size) throw(std::bad_alloc) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) throw() - { - ::free(p); - } - static void* operator new(std::size_t size, void* place) throw() - { - return ::operator new(size, place); - } - static void operator delete(void* p, void* place) throw() - { - ::operator delete(p, place); - } - <%0.upto(GENERATION_LIMIT) {|i|%> - template , typename A<%=j%><%}%>> - T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); - <%}%> + void swap(zone& o); + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t size, void* place) throw() + { + return ::operator new(size, place); + } + static void operator delete(void* p, void* place) throw() + { + ::operator delete(p, place); + } + <%0.upto(GENERATION_LIMIT) {|i|%> + template , typename A<%=j%><%}%>> + T* allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>); + <%}%> private: - void undo_allocate(size_t size); + void undo_allocate(size_t size); - template - static void object_destructor(void* obj); + template + static void object_destructor(void* obj); - void* allocate_expand(size_t size); + void* allocate_expand(size_t size); }; inline zone* zone::create(size_t chunk_size) { - zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); - if (!z) { - return nullptr; - } - new (z) zone(chunk_size); - return z; + zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); + if (!z) { + return nullptr; + } + new (z) zone(chunk_size); + return z; } inline void zone::destroy(zone* z) { - z->~zone(); - ::free(z); + z->~zone(); + ::free(z); } inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) @@ -220,98 +220,98 @@ inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_ inline void* zone::allocate_align(size_t size) { - return allocate_no_align( - ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); + return allocate_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } inline void* zone::allocate_no_align(size_t size) { - if(m_chunk_list.m_free < size) { - return allocate_expand(size); - } + if(m_chunk_list.m_free < size) { + return allocate_expand(size); + } - char* ptr = m_chunk_list.m_ptr; - m_chunk_list.m_free -= size; - m_chunk_list.m_ptr += size; + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; - return ptr; + return ptr; } inline void* zone::allocate_expand(size_t size) { - chunk_list* const cl = &m_chunk_list; + chunk_list* const cl = &m_chunk_list; - size_t sz = m_chunk_size; + size_t sz = m_chunk_size; - while(sz < size) { - sz *= 2; - } + while(sz < size) { + sz *= 2; + } - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - char* ptr = reinterpret_cast(c) + sizeof(chunk); + char* ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = cl->m_head; - cl->m_head = c; - cl->m_free = sz - size; - cl->m_ptr = ptr + size; + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; - return ptr; + return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - m_finalizer_array.push(func, data); + m_finalizer_array.push(func, data); } template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - m_finalizer_array.push(&zone::object_destructor, obj.get()); - obj.release(); + m_finalizer_array.push(&zone::object_destructor, obj.get()); + obj.release(); } inline void zone::clear() { - m_finalizer_array.clear(); - m_chunk_list.clear(m_chunk_size); + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); } inline void zone::swap(zone& o) { - std::swap(*this, o); + std::swap(*this, o); } template void zone::object_destructor(void* obj) { - reinterpret_cast(obj)->~T(); + reinterpret_cast(obj)->~T(); } inline void zone::undo_allocate(size_t size) { - m_chunk_list.m_ptr -= size; - m_chunk_list.m_free += size; + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(<%=(1..i).map{|j|"a#{j}"}.join(', ')%>); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } <%}%> diff --git a/example/custom.cc b/example/custom.cc index 835ebed9..f892a894 100644 --- a/example/custom.cc +++ b/example/custom.cc @@ -4,55 +4,55 @@ class old_class { public: - old_class() : value("default") { } + old_class() : value("default") { } - std::string value; + std::string value; - MSGPACK_DEFINE(value); + MSGPACK_DEFINE(value); }; class new_class { public: - new_class() : value("default"), flag(-1) { } + new_class() : value("default"), flag(-1) { } - std::string value; - int flag; + std::string value; + int flag; - MSGPACK_DEFINE(value, flag); + MSGPACK_DEFINE(value, flag); }; int main(void) { - { - old_class oc; - new_class nc; + { + old_class oc; + new_class nc; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, oc); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, oc); - msgpack::zone zone; - msgpack::object obj; - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); + msgpack::zone zone; + msgpack::object obj; + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); - obj.convert(&nc); + obj.convert(&nc); - std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl; - } + std::cout << obj << " value=" << nc.value << " flag=" << nc.flag << std::endl; + } - { - new_class nc; - old_class oc; + { + new_class nc; + old_class oc; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, nc); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, nc); - msgpack::zone zone; - msgpack::object obj; - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); + msgpack::zone zone; + msgpack::object obj; + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); - obj.convert(&oc); + obj.convert(&oc); - std::cout << obj << " value=" << oc.value << std::endl; - } + std::cout << obj << " value=" << oc.value << std::endl; + } } diff --git a/example/protocol.cc b/example/protocol.cc index 9a969179..efc431f7 100644 --- a/example/protocol.cc +++ b/example/protocol.cc @@ -4,83 +4,83 @@ #include namespace myprotocol { - using namespace msgpack::type; - using msgpack::define; + using namespace msgpack::type; + using msgpack::define; - struct Get : define< tuple > { - Get() { } - Get(uint32_t f, const std::string& k) : - define_type(msgpack_type(f, k)) { } - uint32_t& flags() { return msgpack::type::get<0>(*this); } - std::string& key() { return msgpack::type::get<1>(*this); } - }; + struct Get : define< tuple > { + Get() { } + Get(uint32_t f, const std::string& k) : + define_type(msgpack_type(f, k)) { } + uint32_t& flags() { return msgpack::type::get<0>(*this); } + std::string& key() { return msgpack::type::get<1>(*this); } + }; - struct Put : define< tuple > { - Put() { } - Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) : - define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { } - uint32_t& flags() { return msgpack::type::get<0>(*this); } - std::string& key() { return msgpack::type::get<1>(*this); } - raw_ref& value() { return msgpack::type::get<2>(*this); } - }; + struct Put : define< tuple > { + Put() { } + Put(uint32_t f, const std::string& k, const char* valref, uint32_t vallen) : + define_type(msgpack_type( f, k, raw_ref(valref,vallen) )) { } + uint32_t& flags() { return msgpack::type::get<0>(*this); } + std::string& key() { return msgpack::type::get<1>(*this); } + raw_ref& value() { return msgpack::type::get<2>(*this); } + }; - struct MultiGet : define< std::vector > { - }; + struct MultiGet : define< std::vector > { + }; } int main(void) { - // send Get request - std::stringstream stream; - { - myprotocol::Get req; - req.flags() = 0; - req.key() = "key0"; - msgpack::pack(stream, req); - } + // send Get request + std::stringstream stream; + { + myprotocol::Get req; + req.flags() = 0; + req.key() = "key0"; + msgpack::pack(stream, req); + } - stream.seekg(0); + stream.seekg(0); - // receive Get request - { - std::string buffer(stream.str()); + // receive Get request + { + std::string buffer(stream.str()); - msgpack::zone mempool; - msgpack::object o = - msgpack::unpack(buffer.data(), buffer.size(), mempool); + msgpack::zone mempool; + msgpack::object o = + msgpack::unpack(buffer.data(), buffer.size(), mempool); - myprotocol::Get req; - msgpack::convert(req, o); - std::cout << "received: " << o << std::endl; - } + myprotocol::Get req; + msgpack::convert(req, o); + std::cout << "received: " << o << std::endl; + } - stream.str(""); + stream.str(""); - // send MultiGet request - { - myprotocol::MultiGet req; - req.push_back( myprotocol::Get(1, "key1") ); - req.push_back( myprotocol::Get(2, "key2") ); - req.push_back( myprotocol::Get(3, "key3") ); - msgpack::pack(stream, req); - } + // send MultiGet request + { + myprotocol::MultiGet req; + req.push_back( myprotocol::Get(1, "key1") ); + req.push_back( myprotocol::Get(2, "key2") ); + req.push_back( myprotocol::Get(3, "key3") ); + msgpack::pack(stream, req); + } - stream.seekg(0); + stream.seekg(0); - // receive MultiGet request - { - std::string buffer(stream.str()); + // receive MultiGet request + { + std::string buffer(stream.str()); - msgpack::zone mempool; - msgpack::object o = - msgpack::unpack(buffer.data(), buffer.size(), mempool); + msgpack::zone mempool; + msgpack::object o = + msgpack::unpack(buffer.data(), buffer.size(), mempool); - myprotocol::MultiGet req; - msgpack::convert(req, o); - std::cout << "received: " << o << std::endl; - } + myprotocol::MultiGet req; + msgpack::convert(req, o); + std::cout << "received: " << o << std::endl; + } } diff --git a/example/simple.c b/example/simple.c index 07fa2f8b..39420a80 100644 --- a/example/simple.c +++ b/example/simple.c @@ -3,35 +3,35 @@ int main(void) { - /* msgpack::sbuffer is a simple buffer implementation. */ - msgpack_sbuffer sbuf; - msgpack_sbuffer_init(&sbuf); + /* msgpack::sbuffer is a simple buffer implementation. */ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); - /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ - msgpack_packer pk; - msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + /* serialize values into the buffer using msgpack_sbuffer_write callback function. */ + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); - msgpack_pack_array(&pk, 3); - msgpack_pack_int(&pk, 1); - msgpack_pack_true(&pk); - msgpack_pack_str(&pk, 7); - msgpack_pack_str_body(&pk, "example", 7); + msgpack_pack_array(&pk, 3); + msgpack_pack_int(&pk, 1); + msgpack_pack_true(&pk); + msgpack_pack_str(&pk, 7); + msgpack_pack_str_body(&pk, "example", 7); - /* deserialize the buffer into msgpack_object instance. */ - /* deserialized object is valid during the msgpack_zone instance alive. */ - msgpack_zone mempool; - msgpack_zone_init(&mempool, 2048); + /* deserialize the buffer into msgpack_object instance. */ + /* deserialized object is valid during the msgpack_zone instance alive. */ + msgpack_zone mempool; + msgpack_zone_init(&mempool, 2048); - msgpack_object deserialized; - msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); + msgpack_object deserialized; + msgpack_unpack(sbuf.data, sbuf.size, NULL, &mempool, &deserialized); - /* print the deserialized object. */ - msgpack_object_print(stdout, deserialized); - puts(""); + /* print the deserialized object. */ + msgpack_object_print(stdout, deserialized); + puts(""); - msgpack_zone_destroy(&mempool); - msgpack_sbuffer_destroy(&sbuf); + msgpack_zone_destroy(&mempool); + msgpack_sbuffer_destroy(&sbuf); - return 0; + return 0; } diff --git a/example/simple.cc b/example/simple.cc index 55ecdf92..5bfd8278 100644 --- a/example/simple.cc +++ b/example/simple.cc @@ -5,33 +5,33 @@ int main(void) { - msgpack::type::tuple src(1, true, "example"); + msgpack::type::tuple src(1, true, "example"); - // serialize the object into the buffer. - // any classes that implements write(const char*,size_t) can be a buffer. - std::stringstream buffer; - msgpack::pack(buffer, src); + // serialize the object into the buffer. + // any classes that implements write(const char*,size_t) can be a buffer. + std::stringstream buffer; + msgpack::pack(buffer, src); - // send the buffer ... - buffer.seekg(0); + // send the buffer ... + buffer.seekg(0); - // deserialize the buffer into msgpack::object instance. - std::string str(buffer.str()); + // deserialize the buffer into msgpack::object instance. + std::string str(buffer.str()); - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; + // deserialized object is valid during the msgpack::zone instance alive. + msgpack::zone mempool; - msgpack::object deserialized; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + msgpack::object deserialized; + msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); - // msgpack::object supports ostream. - std::cout << deserialized << std::endl; + // msgpack::object supports ostream. + std::cout << deserialized << std::endl; - // convert msgpack::object instance into the original type. - // if the type is mismatched, it throws msgpack::type_error exception. - msgpack::type::tuple dst; - deserialized.convert(&dst); + // convert msgpack::object instance into the original type. + // if the type is mismatched, it throws msgpack::type_error exception. + msgpack::type::tuple dst; + deserialized.convert(&dst); - return 0; + return 0; } diff --git a/example/speed_test.cc b/example/speed_test.cc index e085c945..b711c15e 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -9,59 +9,59 @@ #include void test_map_pack_unpack() { - std::cout << "[TEST][map_pack_unpack]" << std::endl; - // setup - std::cout << "Setting up map data..." << std::endl; - std::map m1; - int const num = 30000000L; - for (int i = 0; i < num; ++i) m1[i] = i; - std::cout << "Start packing..." << std::endl; - std::stringstream buffer; - { - boost::timer::cpu_timer timer; - msgpack::pack(buffer, m1); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Pack finished..." << std::endl; + std::cout << "[TEST][map_pack_unpack]" << std::endl; + // setup + std::cout << "Setting up map data..." << std::endl; + std::map m1; + int const num = 30000000L; + for (int i = 0; i < num; ++i) m1[i] = i; + std::cout << "Start packing..." << std::endl; + std::stringstream buffer; + { + boost::timer::cpu_timer timer; + msgpack::pack(buffer, m1); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Pack finished..." << std::endl; - buffer.seekg(0); - std::string str(buffer.str()); + buffer.seekg(0); + std::string str(buffer.str()); - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; - msgpack::object deserialized; - std::cout << "Start unpacking..." << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; + // deserialized object is valid during the msgpack::zone instance alive. + msgpack::zone mempool; + msgpack::object deserialized; + std::cout << "Start unpacking..." << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; - msgpack::unpacked unpacked; - std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(&unpacked, str.data(), str.size()); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; - std::map m2; - std::cout << "Start converting..." << std::endl; - { - boost::timer::cpu_timer timer; - deserialized.convert(&m2); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Convert finished..." << std::endl; + msgpack::unpacked unpacked; + std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(&unpacked, str.data(), str.size()); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + std::map m2; + std::cout << "Start converting..." << std::endl; + { + boost::timer::cpu_timer timer; + deserialized.convert(&m2); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Convert finished..." << std::endl; } int main(void) { - test_map_pack_unpack(); + test_map_pack_unpack(); } diff --git a/example/speed_test_nested_array.cc b/example/speed_test_nested_array.cc index 714ead3b..8260f257 100644 --- a/example/speed_test_nested_array.cc +++ b/example/speed_test_nested_array.cc @@ -10,81 +10,81 @@ template struct vecvec { - typedef std::vector::type> type; - static void fill(type& v, std::size_t num_of_elems, T const& val) { - for (int elem = 0; elem < num_of_elems; ++elem) { - typename vecvec::type child; - vecvec::fill(child, num_of_elems, val); - v.push_back(child); - } - } + typedef std::vector::type> type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + typename vecvec::type child; + vecvec::fill(child, num_of_elems, val); + v.push_back(child); + } + } }; template struct vecvec { - typedef std::vector type; - static void fill(type& v, std::size_t num_of_elems, T const& val) { - for (int elem = 0; elem < num_of_elems; ++elem) { - v.push_back(val); - } - } + typedef std::vector type; + static void fill(type& v, std::size_t num_of_elems, T const& val) { + for (int elem = 0; elem < num_of_elems; ++elem) { + v.push_back(val); + } + } }; void test_array_of_array() { - std::cout << "[TEST][array_of_array]" << std::endl; - // setup - int const depth = 16; - std::cout << "Setting up array data..." << std::endl; - typename vecvec::type v1; - vecvec::fill(v1, 3, 42); + std::cout << "[TEST][array_of_array]" << std::endl; + // setup + int const depth = 16; + std::cout << "Setting up array data..." << std::endl; + typename vecvec::type v1; + vecvec::fill(v1, 3, 42); - std::cout << "Start packing..." << std::endl; - std::stringstream buffer; - { - boost::timer::cpu_timer timer; - msgpack::pack(buffer, v1); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Pack finished..." << std::endl; + std::cout << "Start packing..." << std::endl; + std::stringstream buffer; + { + boost::timer::cpu_timer timer; + msgpack::pack(buffer, v1); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Pack finished..." << std::endl; - buffer.seekg(0); - std::string str(buffer.str()); + buffer.seekg(0); + std::string str(buffer.str()); - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; - msgpack::object deserialized; - std::cout << "Start unpacking..." << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; + // deserialized object is valid during the msgpack::zone instance alive. + msgpack::zone mempool; + msgpack::object deserialized; + std::cout << "Start unpacking..." << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; - msgpack::unpacked unpacked; - std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(&unpacked, str.data(), str.size()); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; - typename vecvec::type v2; - std::cout << "Start converting..." << std::endl; - { - boost::timer::cpu_timer timer; - deserialized.convert(&v2); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Convert finished..." << std::endl; + msgpack::unpacked unpacked; + std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; + { + boost::timer::cpu_timer timer; + msgpack::unpack(&unpacked, str.data(), str.size()); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Unpack finished..." << std::endl; + typename vecvec::type v2; + std::cout << "Start converting..." << std::endl; + { + boost::timer::cpu_timer timer; + deserialized.convert(&v2); + std::string result = timer.format(); + std::cout << result << std::endl; + } + std::cout << "Convert finished..." << std::endl; } int main(void) { - test_array_of_array(); + test_array_of_array(); } diff --git a/example/speed_test_uint32_array.c b/example/speed_test_uint32_array.c index 9f259082..cc40cc7e 100644 --- a/example/speed_test_uint32_array.c +++ b/example/speed_test_uint32_array.c @@ -3,34 +3,34 @@ void test() { - size_t size = 10000000; - msgpack_sbuffer buf; - msgpack_sbuffer_init(&buf); + size_t size = 10000000; + msgpack_sbuffer buf; + msgpack_sbuffer_init(&buf); - msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); + msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); - msgpack_pack_array(pk, size); - { - int idx = 0; - for (; idx < size; ++idx) - msgpack_pack_uint32(pk, 1); - } - msgpack_packer_free(pk); + msgpack_pack_array(pk, size); + { + int idx = 0; + for (; idx < size; ++idx) + msgpack_pack_uint32(pk, 1); + } + msgpack_packer_free(pk); - size_t upk_pos = 0; - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); + size_t upk_pos = 0; + msgpack_unpacked msg; + msgpack_unpacked_init(&msg); - while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { - } + while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { + } - msgpack_sbuffer_destroy(&buf); + msgpack_sbuffer_destroy(&buf); } int main(int argc, char **argv) { - int i = 0; - for (; i < 10; ++i) test(); - return 0; + int i = 0; + for (; i < 10; ++i) test(); + return 0; } diff --git a/example/speed_test_uint64_array.c b/example/speed_test_uint64_array.c index e8378dc3..8f3d0dc2 100644 --- a/example/speed_test_uint64_array.c +++ b/example/speed_test_uint64_array.c @@ -3,35 +3,35 @@ void test() { - uint64_t test_u64 = 0xFFF0000000000001LL; - size_t size = 10000000; - msgpack_sbuffer buf; - msgpack_sbuffer_init(&buf); + uint64_t test_u64 = 0xFFF0000000000001LL; + size_t size = 10000000; + msgpack_sbuffer buf; + msgpack_sbuffer_init(&buf); - msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); + msgpack_packer * pk = msgpack_packer_new(&buf, msgpack_sbuffer_write); - msgpack_pack_array(pk, size); - { - int idx = 0; - for (; idx < size; ++idx) - msgpack_pack_uint64(pk, test_u64); - } - msgpack_packer_free(pk); + msgpack_pack_array(pk, size); + { + int idx = 0; + for (; idx < size; ++idx) + msgpack_pack_uint64(pk, test_u64); + } + msgpack_packer_free(pk); - size_t upk_pos = 0; - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); + size_t upk_pos = 0; + msgpack_unpacked msg; + msgpack_unpacked_init(&msg); - while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { - } + while (msgpack_unpack_next(&msg, buf.data, buf.size, &upk_pos)) { + } - msgpack_sbuffer_destroy(&buf); + msgpack_sbuffer_destroy(&buf); } int main(int argc, char **argv) { - int i = 0; - for (; i < 10; ++i) test(); - return 0; + int i = 0; + for (; i < 10; ++i) test(); + return 0; } diff --git a/example/stream.cc b/example/stream.cc index 08d72408..094e9984 100644 --- a/example/stream.cc +++ b/example/stream.cc @@ -9,125 +9,125 @@ class Server { public: - Server(int sock) : m_sock(sock) { } + Server(int sock) : m_sock(sock) { } - ~Server() { } + ~Server() { } - typedef std::auto_ptr auto_zone; + typedef std::auto_ptr auto_zone; - void socket_readable() - { - m_pac.reserve_buffer(1024); + void socket_readable() + { + m_pac.reserve_buffer(1024); - ssize_t count = - read(m_sock, m_pac.buffer(), m_pac.buffer_capacity()); + ssize_t count = + read(m_sock, m_pac.buffer(), m_pac.buffer_capacity()); - if(count <= 0) { - if(count == 0) { - throw std::runtime_error("connection closed"); - } - if(errno == EAGAIN || errno == EINTR) { - return; - } - throw std::runtime_error(strerror(errno)); - } + if(count <= 0) { + if(count == 0) { + throw std::runtime_error("connection closed"); + } + if(errno == EAGAIN || errno == EINTR) { + return; + } + throw std::runtime_error(strerror(errno)); + } - m_pac.buffer_consumed(count); + m_pac.buffer_consumed(count); - msgpack::unpacked result; - while (m_pac.next(&result)) { - msgpack::object msg = result.get(); - auto_zone& life = result.zone(); - process_message(msg, life); - } + msgpack::unpacked result; + while (m_pac.next(&result)) { + msgpack::object msg = result.get(); + auto_zone& life = result.zone(); + process_message(msg, life); + } - if(m_pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } + if(m_pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } private: - void process_message(msgpack::object msg, auto_zone& life) - { - std::cout << "message reached: " << msg << std::endl; - } + void process_message(msgpack::object msg, auto_zone& life) + { + std::cout << "message reached: " << msg << std::endl; + } private: - int m_sock; - msgpack::unpacker m_pac; + int m_sock; + msgpack::unpacker m_pac; }; static void* run_server(void* arg) try { - Server* srv = reinterpret_cast(arg); + Server* srv = reinterpret_cast(arg); - while(true) { - srv->socket_readable(); - } - return NULL; + while(true) { + srv->socket_readable(); + } + return NULL; } catch (std::exception& e) { - std::cerr << "error while processing client packet: " - << e.what() << std::endl; - return NULL; + std::cerr << "error while processing client packet: " + << e.what() << std::endl; + return NULL; } catch (...) { - std::cerr << "error while processing client packet: " - << "unknown error" << std::endl; - return NULL; + std::cerr << "error while processing client packet: " + << "unknown error" << std::endl; + return NULL; } struct fwriter { - fwriter(int fd) : m_fp( fdopen(fd, "w") ) { } + fwriter(int fd) : m_fp( fdopen(fd, "w") ) { } - void write(const char* buf, size_t buflen) - { - size_t count = fwrite(buf, buflen, 1, m_fp); - if(count < 1) { - std::cout << buflen << std::endl; - std::cout << count << std::endl; - throw std::runtime_error(strerror(errno)); - } - } + void write(const char* buf, size_t buflen) + { + size_t count = fwrite(buf, buflen, 1, m_fp); + if(count < 1) { + std::cout << buflen << std::endl; + std::cout << count << std::endl; + throw std::runtime_error(strerror(errno)); + } + } - void flush() { fflush(m_fp); } + void flush() { fflush(m_fp); } - void close() { fclose(m_fp); } + void close() { fclose(m_fp); } private: - FILE* m_fp; + FILE* m_fp; }; int main(void) { - int pair[2]; - pipe(pair); + int pair[2]; + pipe(pair); - // run server thread - Server srv(pair[0]); - pthread_t thread; - pthread_create(&thread, NULL, - run_server, reinterpret_cast(&srv)); + // run server thread + Server srv(pair[0]); + pthread_t thread; + pthread_create(&thread, NULL, + run_server, reinterpret_cast(&srv)); - // client thread: - fwriter writer(pair[1]); - msgpack::packer pk(writer); + // client thread: + fwriter writer(pair[1]); + msgpack::packer pk(writer); - typedef msgpack::type::tuple put_t; - typedef msgpack::type::tuple get_t; + typedef msgpack::type::tuple put_t; + typedef msgpack::type::tuple get_t; - put_t req1("put", "apple", "red"); - put_t req2("put", "lemon", "yellow"); - get_t req3("get", "apple"); - pk.pack(req1); - pk.pack(req2); - pk.pack(req3); - writer.flush(); - writer.close(); + put_t req1("put", "apple", "red"); + put_t req2("put", "lemon", "yellow"); + get_t req3("get", "apple"); + pk.pack(req1); + pk.pack(req2); + pk.pack(req3); + writer.flush(); + writer.close(); - pthread_join(thread, NULL); + pthread_join(thread, NULL); } diff --git a/include/msgpack/adaptor/bool.hpp b/include/msgpack/adaptor/bool.hpp index 06dd3477..e027ad51 100644 --- a/include/msgpack/adaptor/bool.hpp +++ b/include/msgpack/adaptor/bool.hpp @@ -26,27 +26,27 @@ namespace msgpack { inline bool& operator>> (object const& o, bool& v) { - if(o.type != type::BOOLEAN) { throw type_error(); } - v = o.via.boolean; - return v; + if(o.type != type::BOOLEAN) { throw type_error(); } + v = o.via.boolean; + return v; } template inline packer& operator<< (packer& o, const bool& v) { - if(v) { o.pack_true(); } - else { o.pack_false(); } - return o; + if(v) { o.pack_true(); } + else { o.pack_false(); } + return o; } inline void operator<< (object& o, bool v) { - o.type = type::BOOLEAN; - o.via.boolean = v; + o.type = type::BOOLEAN; + o.via.boolean = v; } inline void operator<< (object::with_zone& o, bool v) - { static_cast(o) << v; } + { static_cast(o) << v; } } // namespace msgpack diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index b599b4c5..6c9d0694 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -28,91 +28,91 @@ namespace msgpack { // --- Pack ( from tuple to packer stream --- template struct StdTuplePacker { - static void pack( - packer& o, - const Tuple& v) { - StdTuplePacker::pack(o, v); - o.pack(std::get(v)); - } + static void pack( + packer& o, + const Tuple& v) { + StdTuplePacker::pack(o, v); + o.pack(std::get(v)); + } }; template struct StdTuplePacker { - static void pack ( - packer& o, - const Tuple& v) { - o.pack(std::get<0>(v)); - } + static void pack ( + packer& o, + const Tuple& v) { + o.pack(std::get<0>(v)); + } }; template const packer& operator<< ( - packer& o, - const std::tuple& v) { - o.pack_array(sizeof...(Args)); - StdTuplePacker::pack(o, v); - return o; + packer& o, + const std::tuple& v) { + o.pack_array(sizeof...(Args)); + StdTuplePacker::pack(o, v); + return o; } // --- Convert from tuple to object --- template struct StdTupleConverter { - static void convert( - object const& o, - Tuple& v) { - StdTupleConverter::convert(o, v); - o.via.array.ptr[N-1].convert(v))>::type>(std::get(v)); - } + static void convert( + object const& o, + Tuple& v) { + StdTupleConverter::convert(o, v); + o.via.array.ptr[N-1].convert(v))>::type>(std::get(v)); + } }; template struct StdTupleConverter { - static void convert ( - object const& o, - Tuple& v) { - o.via.array.ptr[0].convert(v))>::type>(std::get<0>(v)); - } + static void convert ( + object const& o, + Tuple& v) { + o.via.array.ptr[0].convert(v))>::type>(std::get<0>(v)); + } }; template std::tuple& operator>> ( - object const& o, - std::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < sizeof...(Args)) { throw type_error(); } - StdTupleConverter::convert(o, v); - return v; + object const& o, + std::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw type_error(); } + StdTupleConverter::convert(o, v); + return v; } // --- Convert from tuple to object with zone --- template struct StdTupleToObjectWithZone { - static void convert( - object::with_zone& o, - const Tuple& v) { - StdTupleToObjectWithZone::convert(o, v); - o.via.array.ptr[N-1] = object(std::get(v), o.zone); - } + static void convert( + object::with_zone& o, + const Tuple& v) { + StdTupleToObjectWithZone::convert(o, v); + o.via.array.ptr[N-1] = object(std::get(v), o.zone); + } }; template struct StdTupleToObjectWithZone { - static void convert ( - object::with_zone& o, - const Tuple& v) { - o.via.array.ptr[0] = object(std::get<0>(v), o.zone); - } + static void convert ( + object::with_zone& o, + const Tuple& v) { + o.via.array.ptr[0] = object(std::get<0>(v), o.zone); + } }; template inline void operator<< ( - object::with_zone& o, - std::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); - o.via.array.size = sizeof...(Args); - StdTupleToObjectWithZone::convert(o, v); + object::with_zone& o, + std::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); + o.via.array.size = sizeof...(Args); + StdTupleToObjectWithZone::convert(o, v); } } // msgpack diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index be5ad8a4..089c04f2 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -27,47 +27,47 @@ namespace msgpack { template inline std::deque& operator>> (object const& o, std::deque& v) { - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - typename std::deque::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(*it); - } - return v; + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + typename std::deque::iterator it = v.begin(); + for(; p < pend; ++p, ++it) { + p->convert(*it); + } + return v; } template inline packer& operator<< (packer& o, const std::deque& v) { - o.pack_array(v.size()); - for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; + o.pack_array(v.size()); + for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; } template inline void operator<< (object::with_zone& o, const std::deque& v) { - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::deque::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::deque::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } } diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index 38d3d8cb..7089c7f7 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -19,20 +19,20 @@ #define MSGPACK_CPP03_DEFINE_HPP #define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object const& o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - }\ - template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ - } + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object const& o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } // MSGPACK_ADD_ENUM must be used in the global namespace. #define MSGPACK_ADD_ENUM(enum) \ @@ -71,3389 +71,3389 @@ struct define; template <> struct define<> { - typedef define<> value_type; - typedef tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(0); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = nullptr; - o->via.array.size = 0; - } + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = nullptr; + o->via.array.size = 0; + } }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0) : - a0(_a0) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(1); - - pk.pack(a0); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*1)); - o->via.array.size = 1; - - o->via.array.ptr[0] = object(a0, z); - } - - A0& a0; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0) : + a0(_a0) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(1); + + pk.pack(a0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*1)); + o->via.array.size = 1; + + o->via.array.ptr[0] = object(a0, z); + } + + A0& a0; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1) : - a0(_a0), a1(_a1) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(2); - - pk.pack(a0); - pk.pack(a1); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*2)); - o->via.array.size = 2; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - } - - A0& a0; - A1& a1; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1) : + a0(_a0), a1(_a1) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(2); + + pk.pack(a0); + pk.pack(a1); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*2)); + o->via.array.size = 2; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + } + + A0& a0; + A1& a1; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2) : - a0(_a0), a1(_a1), a2(_a2) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(3); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*3)); - o->via.array.size = 3; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - } - - A0& a0; - A1& a1; - A2& a2; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(3); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*3)); + o->via.array.size = 3; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + } + + A0& a0; + A1& a1; + A2& a2; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(4); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*4)); - o->via.array.size = 4; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(4); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*4)); + o->via.array.size = 4; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(5); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*5)); - o->via.array.size = 5; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(5); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*5)); + o->via.array.size = 5; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(6); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*6)); - o->via.array.size = 6; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(6); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*6)); + o->via.array.size = 6; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(7); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*7)); - o->via.array.size = 7; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(7); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*7)); + o->via.array.size = 7; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(8); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*8)); - o->via.array.size = 8; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(8); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*8)); + o->via.array.size = 8; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(9); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*9)); - o->via.array.size = 9; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(9); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*9)); + o->via.array.size = 9; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(10); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*10)); - o->via.array.size = 10; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(10); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*10)); + o->via.array.size = 10; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(11); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*11)); - o->via.array.size = 11; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(11); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*11)); + o->via.array.size = 11; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(12); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*12)); - o->via.array.size = 12; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; + typedef define value_type; + typedef tuple tuple_type; + define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(12); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*12)); + o->via.array.size = 12; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + } + + A0& a0; + A1& a1; + A2& a2; + A3& a3; + A4& a4; + A5& a5; + A6& a6; + A7& a7; + A8& a8; + A9& a9; + A10& a10; + A11& a11; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(13); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*13)); - o->via.array.size = 13; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(13); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*13)); + o->via.array.size = 13; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(14); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*14)); - o->via.array.size = 14; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(14); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*14)); + o->via.array.size = 14; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(15); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*15)); - o->via.array.size = 15; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(15); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*15)); + o->via.array.size = 15; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(16); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*16)); - o->via.array.size = 16; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(16); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*16)); + o->via.array.size = 16; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(17); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*17)); - o->via.array.size = 17; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(17); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*17)); + o->via.array.size = 17; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(18); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*18)); - o->via.array.size = 18; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(18); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*18)); + o->via.array.size = 18; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(19); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*19)); - o->via.array.size = 19; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(19); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*19)); + o->via.array.size = 19; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(20); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*20)); - o->via.array.size = 20; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(20); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*20)); + o->via.array.size = 20; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(21); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*21)); - o->via.array.size = 21; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(21); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*21)); + o->via.array.size = 21; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(22); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*22)); - o->via.array.size = 22; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(22); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*22)); + o->via.array.size = 22; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(23); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*23)); - o->via.array.size = 23; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(23); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*23)); + o->via.array.size = 23; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(24); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*24)); - o->via.array.size = 24; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(24); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*24)); + o->via.array.size = 24; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(25); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*25)); - o->via.array.size = 25; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(25); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*25)); + o->via.array.size = 25; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(26); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*26)); - o->via.array.size = 26; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(26); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*26)); + o->via.array.size = 26; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(27); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*27)); - o->via.array.size = 27; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(27); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*27)); + o->via.array.size = 27; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(28); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*28)); - o->via.array.size = 28; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(28); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*28)); + o->via.array.size = 28; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(29); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*29)); - o->via.array.size = 29; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(29); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*29)); + o->via.array.size = 29; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(30); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 30: ptr[29].convert(a29); - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*30)); - o->via.array.size = 30; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - o->via.array.ptr[29] = object(a29, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(30); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 30: ptr[29].convert(a29); + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*30)); + o->via.array.size = 30; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(31); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - pk.pack(a30); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 31: ptr[30].convert(a30); - case 30: ptr[29].convert(a29); - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*31)); - o->via.array.size = 31; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - o->via.array.ptr[29] = object(a29, z); - o->via.array.ptr[30] = object(a30, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(31); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + pk.pack(a30); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 31: ptr[30].convert(a30); + case 30: ptr[29].convert(a29); + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*31)); + o->via.array.size = 31; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + o->via.array.ptr[30] = object(a30, z); + } + + 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; }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(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) : - 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) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(32); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - pk.pack(a30); - pk.pack(a31); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 32: ptr[31].convert(a31); - case 31: ptr[30].convert(a30); - case 30: ptr[29].convert(a29); - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*32)); - o->via.array.size = 32; - - o->via.array.ptr[0] = object(a0, z); - o->via.array.ptr[1] = object(a1, z); - o->via.array.ptr[2] = object(a2, z); - o->via.array.ptr[3] = object(a3, z); - o->via.array.ptr[4] = object(a4, z); - o->via.array.ptr[5] = object(a5, z); - o->via.array.ptr[6] = object(a6, z); - o->via.array.ptr[7] = object(a7, z); - o->via.array.ptr[8] = object(a8, z); - o->via.array.ptr[9] = object(a9, z); - o->via.array.ptr[10] = object(a10, z); - o->via.array.ptr[11] = object(a11, z); - o->via.array.ptr[12] = object(a12, z); - o->via.array.ptr[13] = object(a13, z); - o->via.array.ptr[14] = object(a14, z); - o->via.array.ptr[15] = object(a15, z); - o->via.array.ptr[16] = object(a16, z); - o->via.array.ptr[17] = object(a17, z); - o->via.array.ptr[18] = object(a18, z); - o->via.array.ptr[19] = object(a19, z); - o->via.array.ptr[20] = object(a20, z); - o->via.array.ptr[21] = object(a21, z); - o->via.array.ptr[22] = object(a22, z); - o->via.array.ptr[23] = object(a23, z); - o->via.array.ptr[24] = object(a24, z); - o->via.array.ptr[25] = object(a25, z); - o->via.array.ptr[26] = object(a26, z); - o->via.array.ptr[27] = object(a27, z); - o->via.array.ptr[28] = object(a28, z); - o->via.array.ptr[29] = object(a29, z); - o->via.array.ptr[30] = object(a30, z); - o->via.array.ptr[31] = object(a31, z); - } - - 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; + typedef define value_type; + typedef tuple tuple_type; + define(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) : + 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) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(32); + + pk.pack(a0); + pk.pack(a1); + pk.pack(a2); + pk.pack(a3); + pk.pack(a4); + pk.pack(a5); + pk.pack(a6); + pk.pack(a7); + pk.pack(a8); + pk.pack(a9); + pk.pack(a10); + pk.pack(a11); + pk.pack(a12); + pk.pack(a13); + pk.pack(a14); + pk.pack(a15); + pk.pack(a16); + pk.pack(a17); + pk.pack(a18); + pk.pack(a19); + pk.pack(a20); + pk.pack(a21); + pk.pack(a22); + pk.pack(a23); + pk.pack(a24); + pk.pack(a25); + pk.pack(a26); + pk.pack(a27); + pk.pack(a28); + pk.pack(a29); + pk.pack(a30); + pk.pack(a31); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + const size_t size = o.via.array.size; + if(size > 0) { + msgpack::object *ptr = o.via.array.ptr; + switch(size) { + default: + case 32: ptr[31].convert(a31); + case 31: ptr[30].convert(a30); + case 30: ptr[29].convert(a29); + case 29: ptr[28].convert(a28); + case 28: ptr[27].convert(a27); + case 27: ptr[26].convert(a26); + case 26: ptr[25].convert(a25); + case 25: ptr[24].convert(a24); + case 24: ptr[23].convert(a23); + case 23: ptr[22].convert(a22); + case 22: ptr[21].convert(a21); + case 21: ptr[20].convert(a20); + case 20: ptr[19].convert(a19); + case 19: ptr[18].convert(a18); + case 18: ptr[17].convert(a17); + case 17: ptr[16].convert(a16); + case 16: ptr[15].convert(a15); + case 15: ptr[14].convert(a14); + case 14: ptr[13].convert(a13); + case 13: ptr[12].convert(a12); + case 12: ptr[11].convert(a11); + case 11: ptr[10].convert(a10); + case 10: ptr[9].convert(a9); + case 9: ptr[8].convert(a8); + case 8: ptr[7].convert(a7); + case 7: ptr[6].convert(a6); + case 6: ptr[5].convert(a5); + case 5: ptr[4].convert(a4); + case 4: ptr[3].convert(a3); + case 3: ptr[2].convert(a2); + case 2: ptr[1].convert(a1); + case 1: ptr[0].convert(a0); + } + } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*32)); + o->via.array.size = 32; + + o->via.array.ptr[0] = object(a0, z); + o->via.array.ptr[1] = object(a1, z); + o->via.array.ptr[2] = object(a2, z); + o->via.array.ptr[3] = object(a3, z); + o->via.array.ptr[4] = object(a4, z); + o->via.array.ptr[5] = object(a5, z); + o->via.array.ptr[6] = object(a6, z); + o->via.array.ptr[7] = object(a7, z); + o->via.array.ptr[8] = object(a8, z); + o->via.array.ptr[9] = object(a9, z); + o->via.array.ptr[10] = object(a10, z); + o->via.array.ptr[11] = object(a11, z); + o->via.array.ptr[12] = object(a12, z); + o->via.array.ptr[13] = object(a13, z); + o->via.array.ptr[14] = object(a14, z); + o->via.array.ptr[15] = object(a15, z); + o->via.array.ptr[16] = object(a16, z); + o->via.array.ptr[17] = object(a17, z); + o->via.array.ptr[18] = object(a18, z); + o->via.array.ptr[19] = object(a19, z); + o->via.array.ptr[20] = object(a20, z); + o->via.array.ptr[21] = object(a21, z); + o->via.array.ptr[22] = object(a22, z); + o->via.array.ptr[23] = object(a23, z); + o->via.array.ptr[24] = object(a24, z); + o->via.array.ptr[25] = object(a25, z); + o->via.array.ptr[26] = object(a26, z); + o->via.array.ptr[27] = object(a27, z); + o->via.array.ptr[28] = object(a28, z); + o->via.array.ptr[29] = object(a29, z); + o->via.array.ptr[30] = object(a30, z); + o->via.array.ptr[31] = object(a31, z); + } + + 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; }; inline define<> make_define() { - return define<>(); + return define<>(); } template define make_define(A0& a0) { - return define(a0); + return define(a0); } template define make_define(A0& a0, A1& a1) { - return define(a0, a1); + return define(a0, a1); } template define make_define(A0& a0, A1& a1, A2& a2) { - return define(a0, a1, a2); + return define(a0, a1, a2); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3) { - return define(a0, a1, a2, a3); + return define(a0, a1, a2, a3); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) { - return define(a0, a1, a2, a3, a4); + return define(a0, a1, a2, a3, a4); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) { - return define(a0, a1, a2, a3, a4, a5); + return define(a0, a1, a2, a3, a4, a5); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) { - return define(a0, a1, a2, a3, a4, a5, a6); + return define(a0, a1, a2, a3, a4, a5, a6); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) { - return define(a0, a1, a2, a3, a4, a5, a6, a7); + return define(a0, a1, a2, a3, a4, a5, a6, a7); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); } template define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); } template define make_define(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) { - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); + return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); } template define make_define(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) { - return define(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); + return define(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); } template define make_define(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) { - return define(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); + return define(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); } template define make_define(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) { - return define(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); + return define(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); } template define make_define(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) { - return define(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); + return define(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); } template define make_define(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) { - return define(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); + return define(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); } template define make_define(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) { - return define(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); + return define(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); } template define make_define(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) { - return define(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); + return define(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); } template define make_define(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) { - return define(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); + return define(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); } diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp index dd520cb1..a6685c46 100644 --- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -39,4845 +39,4845 @@ struct const_tuple_element; template struct tuple_type { - typedef T type; - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; + typedef T type; + typedef T value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; }; template struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef T& transparent_reference; + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef T& transparent_reference; }; template struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; + typedef T type; + typedef T& value_type; + typedef T& reference; + typedef const T& const_reference; + typedef const T& transparent_reference; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : m_x(x.a29) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : m_x(x.a29) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : m_x(x.a30) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a30) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a0) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a1) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a2) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a3) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a4) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a5) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a6) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a7) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a8) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a9) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a10) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a11) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a12) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a13) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a14) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a15) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a16) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a17) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a18) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a19) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a20) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a21) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a22) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a23) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a24) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a25) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a26) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a27) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a28) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : m_x(x.a29) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a29) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : m_x(x.a30) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a30) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; template struct tuple_element, 31> : tuple_type { - tuple_element(tuple& x) : m_x(x.a31) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } + tuple_element(tuple& x) : m_x(x.a31) {} + typename tuple_type::reference get() { return m_x; } + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::reference m_x; + typename tuple_type::reference m_x; }; @@ -4886,4312 +4886,4312 @@ private: template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a29) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a29) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a30) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a30) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a0) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a1) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a2) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a3) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a4) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a5) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a6) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a7) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a8) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a9) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a10) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a11) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a12) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a13) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a14) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a15) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a16) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a17) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a18) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a19) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a20) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a21) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a22) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a23) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a24) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a25) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a26) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a27) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a28) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a29) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a29) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a30) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a30) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template struct const_tuple_element, 31> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a31) {} - typename tuple_type::const_reference get() const { return m_x; } + const_tuple_element(const tuple& x) : m_x(x.a31) {} + typename tuple_type::const_reference get() const { return m_x; } private: - typename tuple_type::const_reference m_x; + typename tuple_type::const_reference m_x; }; template <> struct tuple<> { - tuple() {} - tuple(object const& o) { o.convert(*this); } - typedef tuple<> value_type; + tuple() {} + tuple(object const& o) { o.convert(*this); } + typedef tuple<> value_type; }; template struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0) : - a0(_a0) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0) : + a0(_a0) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; }; template @@ -9203,18 +9203,18 @@ inline typename type::const_tuple_element, N>::const_reference g template struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1) : - a0(_a0), a1(_a1) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1) : + a0(_a0), a1(_a1) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; }; template @@ -9226,19 +9226,19 @@ inline typename type::const_tuple_element, N>::const_referen template struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2) : - a0(_a0), a1(_a1), a2(_a2) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2) : + a0(_a0), a1(_a1), a2(_a2) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; }; template @@ -9250,20 +9250,20 @@ inline typename type::const_tuple_element, N>::const_ref template struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; }; template @@ -9275,21 +9275,21 @@ inline typename type::const_tuple_element, N>::const template struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; }; template @@ -9301,22 +9301,22 @@ inline typename type::const_tuple_element, N>::c template struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; }; template @@ -9328,23 +9328,23 @@ inline typename type::const_tuple_element, N template struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; }; template @@ -9356,24 +9356,24 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; }; template @@ -9385,25 +9385,25 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; }; template @@ -9415,26 +9415,26 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; }; template @@ -9446,27 +9446,27 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; }; template @@ -9478,28 +9478,28 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11) : + a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + A0 a0; + A1 a1; + A2 a2; + A3 a3; + A4 a4; + A5 a5; + A6 a6; + A7 a7; + A8 a8; + A9 a9; + A10 a10; + A11 a11; }; template @@ -9511,29 +9511,29 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9545,30 +9545,30 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9580,31 +9580,31 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9616,32 +9616,32 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9653,33 +9653,33 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9691,34 +9691,34 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9730,35 +9730,35 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9770,36 +9770,36 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9811,37 +9811,37 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9853,38 +9853,38 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9896,39 +9896,39 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9940,40 +9940,40 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -9985,41 +9985,41 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10031,42 +10031,42 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10078,43 +10078,43 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10126,44 +10126,44 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10175,45 +10175,45 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10225,46 +10225,46 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10276,47 +10276,47 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10328,48 +10328,48 @@ inline typename type::const_tuple_element struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30, typename tuple_type::transparent_reference _a31) : - 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) {} - tuple(object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - 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; + typedef tuple value_type; + tuple() {} + tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30, typename tuple_type::transparent_reference _a31) : + 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) {} + tuple(object const& o) { o.convert(*this); } + template typename tuple_element::reference get() + { return tuple_element(*this).get(); } + template typename const_tuple_element::const_reference get() const + { return const_tuple_element(*this).get(); } + + 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; }; template @@ -10382,2739 +10382,2739 @@ inline typename type::const_tuple_element make_tuple() { - return tuple<>(); + return tuple<>(); } template tuple make_tuple(typename tuple_type::transparent_reference a0) { - return tuple(a0); + return tuple(a0); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1) { - return tuple(a0, a1); + return tuple(a0, a1); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2) { - return tuple(a0, a1, a2); + return tuple(a0, a1, a2); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3) { - return tuple(a0, a1, a2, a3); + return tuple(a0, a1, a2, a3); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4) { - return tuple(a0, a1, a2, a3, a4); + return tuple(a0, a1, a2, a3, a4); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5) { - return tuple(a0, a1, a2, a3, a4, a5); + return tuple(a0, a1, a2, a3, a4, a5); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6) { - return tuple(a0, a1, a2, a3, a4, a5, a6); + return tuple(a0, a1, a2, a3, a4, a5, a6); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22) { - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); + return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30) { - return 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); + return 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); } template tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31) { - return 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); + return 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); } } // namespace type inline type::tuple<>& operator>> ( - object const& o, - type::tuple<>& v) { - if(o.type != type::ARRAY) { throw type_error(); } - return v; + object const& o, + type::tuple<>& v) { + if(o.type != type::ARRAY) { throw type_error(); } + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 1) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 1) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 2) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 2) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 3) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 3) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 4) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 4) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 5) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 5) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 6) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 6) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 7) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 7) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 8) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 8) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 9) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 9) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 10) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 10) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 11) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 11) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 12) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 12) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 13) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 13) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 14) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 14) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 15) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 15) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 16) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 16) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 17) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 17) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 18) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 18) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 19) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 19) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 20) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 20) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 21) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 21) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 22) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 22) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 23) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 23) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 24) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 24) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 25) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 25) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 26) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - o.via.array.ptr[25].convert::type>(v.template get<25>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 26) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 27) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - o.via.array.ptr[25].convert::type>(v.template get<25>()); - o.via.array.ptr[26].convert::type>(v.template get<26>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 27) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 28) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - o.via.array.ptr[25].convert::type>(v.template get<25>()); - o.via.array.ptr[26].convert::type>(v.template get<26>()); - o.via.array.ptr[27].convert::type>(v.template get<27>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 28) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 29) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - o.via.array.ptr[25].convert::type>(v.template get<25>()); - o.via.array.ptr[26].convert::type>(v.template get<26>()); - o.via.array.ptr[27].convert::type>(v.template get<27>()); - o.via.array.ptr[28].convert::type>(v.template get<28>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 29) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 30) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - o.via.array.ptr[25].convert::type>(v.template get<25>()); - o.via.array.ptr[26].convert::type>(v.template get<26>()); - o.via.array.ptr[27].convert::type>(v.template get<27>()); - o.via.array.ptr[28].convert::type>(v.template get<28>()); - o.via.array.ptr[29].convert::type>(v.template get<29>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 30) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 31) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - o.via.array.ptr[25].convert::type>(v.template get<25>()); - o.via.array.ptr[26].convert::type>(v.template get<26>()); - o.via.array.ptr[27].convert::type>(v.template get<27>()); - o.via.array.ptr[28].convert::type>(v.template get<28>()); - o.via.array.ptr[29].convert::type>(v.template get<29>()); - o.via.array.ptr[30].convert::type>(v.template get<30>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 31) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + o.via.array.ptr[30].convert::type>(v.template get<30>()); + return v; } template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < 32) { throw type_error(); } - - o.via.array.ptr[0].convert::type>(v.template get<0>()); - o.via.array.ptr[1].convert::type>(v.template get<1>()); - o.via.array.ptr[2].convert::type>(v.template get<2>()); - o.via.array.ptr[3].convert::type>(v.template get<3>()); - o.via.array.ptr[4].convert::type>(v.template get<4>()); - o.via.array.ptr[5].convert::type>(v.template get<5>()); - o.via.array.ptr[6].convert::type>(v.template get<6>()); - o.via.array.ptr[7].convert::type>(v.template get<7>()); - o.via.array.ptr[8].convert::type>(v.template get<8>()); - o.via.array.ptr[9].convert::type>(v.template get<9>()); - o.via.array.ptr[10].convert::type>(v.template get<10>()); - o.via.array.ptr[11].convert::type>(v.template get<11>()); - o.via.array.ptr[12].convert::type>(v.template get<12>()); - o.via.array.ptr[13].convert::type>(v.template get<13>()); - o.via.array.ptr[14].convert::type>(v.template get<14>()); - o.via.array.ptr[15].convert::type>(v.template get<15>()); - o.via.array.ptr[16].convert::type>(v.template get<16>()); - o.via.array.ptr[17].convert::type>(v.template get<17>()); - o.via.array.ptr[18].convert::type>(v.template get<18>()); - o.via.array.ptr[19].convert::type>(v.template get<19>()); - o.via.array.ptr[20].convert::type>(v.template get<20>()); - o.via.array.ptr[21].convert::type>(v.template get<21>()); - o.via.array.ptr[22].convert::type>(v.template get<22>()); - o.via.array.ptr[23].convert::type>(v.template get<23>()); - o.via.array.ptr[24].convert::type>(v.template get<24>()); - o.via.array.ptr[25].convert::type>(v.template get<25>()); - o.via.array.ptr[26].convert::type>(v.template get<26>()); - o.via.array.ptr[27].convert::type>(v.template get<27>()); - o.via.array.ptr[28].convert::type>(v.template get<28>()); - o.via.array.ptr[29].convert::type>(v.template get<29>()); - o.via.array.ptr[30].convert::type>(v.template get<30>()); - o.via.array.ptr[31].convert::type>(v.template get<31>()); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < 32) { throw type_error(); } + + o.via.array.ptr[0].convert::type>(v.template get<0>()); + o.via.array.ptr[1].convert::type>(v.template get<1>()); + o.via.array.ptr[2].convert::type>(v.template get<2>()); + o.via.array.ptr[3].convert::type>(v.template get<3>()); + o.via.array.ptr[4].convert::type>(v.template get<4>()); + o.via.array.ptr[5].convert::type>(v.template get<5>()); + o.via.array.ptr[6].convert::type>(v.template get<6>()); + o.via.array.ptr[7].convert::type>(v.template get<7>()); + o.via.array.ptr[8].convert::type>(v.template get<8>()); + o.via.array.ptr[9].convert::type>(v.template get<9>()); + o.via.array.ptr[10].convert::type>(v.template get<10>()); + o.via.array.ptr[11].convert::type>(v.template get<11>()); + o.via.array.ptr[12].convert::type>(v.template get<12>()); + o.via.array.ptr[13].convert::type>(v.template get<13>()); + o.via.array.ptr[14].convert::type>(v.template get<14>()); + o.via.array.ptr[15].convert::type>(v.template get<15>()); + o.via.array.ptr[16].convert::type>(v.template get<16>()); + o.via.array.ptr[17].convert::type>(v.template get<17>()); + o.via.array.ptr[18].convert::type>(v.template get<18>()); + o.via.array.ptr[19].convert::type>(v.template get<19>()); + o.via.array.ptr[20].convert::type>(v.template get<20>()); + o.via.array.ptr[21].convert::type>(v.template get<21>()); + o.via.array.ptr[22].convert::type>(v.template get<22>()); + o.via.array.ptr[23].convert::type>(v.template get<23>()); + o.via.array.ptr[24].convert::type>(v.template get<24>()); + o.via.array.ptr[25].convert::type>(v.template get<25>()); + o.via.array.ptr[26].convert::type>(v.template get<26>()); + o.via.array.ptr[27].convert::type>(v.template get<27>()); + o.via.array.ptr[28].convert::type>(v.template get<28>()); + o.via.array.ptr[29].convert::type>(v.template get<29>()); + o.via.array.ptr[30].convert::type>(v.template get<30>()); + o.via.array.ptr[31].convert::type>(v.template get<31>()); + return v; } template const packer& operator<< ( - packer& o, - const type::tuple<>& v) { - o.pack_array(0); - return o; + packer& o, + const type::tuple<>& v) { + o.pack_array(0); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(1); - - o.pack(v.template get<0>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(1); + + o.pack(v.template get<0>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(2); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(2); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(3); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(3); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(4); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(4); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(5); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(5); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(6); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(6); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(7); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(7); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(8); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(8); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(9); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(9); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(10); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(10); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(11); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(11); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(12); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(12); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(13); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(13); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(14); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(14); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(15); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(15); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(16); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(16); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(17); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(17); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(18); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(18); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(19); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(19); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(20); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(20); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(21); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(21); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(22); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(22); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(23); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(23); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(24); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(24); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(25); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(25); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(26); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(26); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(27); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(27); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(28); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(28); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(29); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(29); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(30); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(30); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(31); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - o.pack(v.template get<30>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(31); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + o.pack(v.template get<30>()); + return o; } template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(32); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - o.pack(v.template get<30>()); - o.pack(v.template get<31>()); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(32); + + o.pack(v.template get<0>()); + o.pack(v.template get<1>()); + o.pack(v.template get<2>()); + o.pack(v.template get<3>()); + o.pack(v.template get<4>()); + o.pack(v.template get<5>()); + o.pack(v.template get<6>()); + o.pack(v.template get<7>()); + o.pack(v.template get<8>()); + o.pack(v.template get<9>()); + o.pack(v.template get<10>()); + o.pack(v.template get<11>()); + o.pack(v.template get<12>()); + o.pack(v.template get<13>()); + o.pack(v.template get<14>()); + o.pack(v.template get<15>()); + o.pack(v.template get<16>()); + o.pack(v.template get<17>()); + o.pack(v.template get<18>()); + o.pack(v.template get<19>()); + o.pack(v.template get<20>()); + o.pack(v.template get<21>()); + o.pack(v.template get<22>()); + o.pack(v.template get<23>()); + o.pack(v.template get<24>()); + o.pack(v.template get<25>()); + o.pack(v.template get<26>()); + o.pack(v.template get<27>()); + o.pack(v.template get<28>()); + o.pack(v.template get<29>()); + o.pack(v.template get<30>()); + o.pack(v.template get<31>()); + return o; } inline void operator<< ( - object::with_zone& o, - const type::tuple<>& v) { - o.type = type::ARRAY; - o.via.array.ptr = nullptr; - o.via.array.size = 0; + object::with_zone& o, + const type::tuple<>& v) { + o.type = type::ARRAY; + o.via.array.ptr = nullptr; + o.via.array.size = 0; } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*1)); - o.via.array.size = 1; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*1)); + o.via.array.size = 1; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*2)); - o.via.array.size = 2; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*2)); + o.via.array.size = 2; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*3)); - o.via.array.size = 3; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*3)); + o.via.array.size = 3; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*4)); - o.via.array.size = 4; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*4)); + o.via.array.size = 4; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*5)); - o.via.array.size = 5; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*5)); + o.via.array.size = 5; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*6)); - o.via.array.size = 6; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*6)); + o.via.array.size = 6; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*7)); - o.via.array.size = 7; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*7)); + o.via.array.size = 7; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*8)); - o.via.array.size = 8; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*8)); + o.via.array.size = 8; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*9)); - o.via.array.size = 9; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*9)); + o.via.array.size = 9; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*10)); - o.via.array.size = 10; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*10)); + o.via.array.size = 10; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*11)); - o.via.array.size = 11; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*11)); + o.via.array.size = 11; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*12)); - o.via.array.size = 12; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*12)); + o.via.array.size = 12; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*13)); - o.via.array.size = 13; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*13)); + o.via.array.size = 13; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*14)); - o.via.array.size = 14; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*14)); + o.via.array.size = 14; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*15)); - o.via.array.size = 15; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*15)); + o.via.array.size = 15; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*16)); - o.via.array.size = 16; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*16)); + o.via.array.size = 16; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*17)); - o.via.array.size = 17; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*17)); + o.via.array.size = 17; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*18)); - o.via.array.size = 18; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*18)); + o.via.array.size = 18; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*19)); - o.via.array.size = 19; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*19)); + o.via.array.size = 19; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*20)); - o.via.array.size = 20; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*20)); + o.via.array.size = 20; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*21)); - o.via.array.size = 21; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*21)); + o.via.array.size = 21; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*22)); - o.via.array.size = 22; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*22)); + o.via.array.size = 22; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*23)); - o.via.array.size = 23; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*23)); + o.via.array.size = 23; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*24)); - o.via.array.size = 24; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*24)); + o.via.array.size = 24; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*25)); - o.via.array.size = 25; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*25)); + o.via.array.size = 25; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*26)); - o.via.array.size = 26; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*26)); + o.via.array.size = 26; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*27)); - o.via.array.size = 27; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*27)); + o.via.array.size = 27; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*28)); - o.via.array.size = 28; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*28)); + o.via.array.size = 28; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*29)); - o.via.array.size = 29; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*29)); + o.via.array.size = 29; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*30)); - o.via.array.size = 30; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = object(v.template get<29>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*30)); + o.via.array.size = 30; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*31)); - o.via.array.size = 31; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = object(v.template get<29>(), o.zone); - o.via.array.ptr[30] = object(v.template get<30>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*31)); + o.via.array.size = 31; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = object(v.template get<30>(), o.zone); } template inline void operator<< ( - object::with_zone& o, - const type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*32)); - o.via.array.size = 32; - - o.via.array.ptr[0] = object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = object(v.template get<29>(), o.zone); - o.via.array.ptr[30] = object(v.template get<30>(), o.zone); - o.via.array.ptr[31] = object(v.template get<31>(), o.zone); + object::with_zone& o, + const type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*32)); + o.via.array.size = 32; + + o.via.array.ptr[0] = object(v.template get<0>(), o.zone); + o.via.array.ptr[1] = object(v.template get<1>(), o.zone); + o.via.array.ptr[2] = object(v.template get<2>(), o.zone); + o.via.array.ptr[3] = object(v.template get<3>(), o.zone); + o.via.array.ptr[4] = object(v.template get<4>(), o.zone); + o.via.array.ptr[5] = object(v.template get<5>(), o.zone); + o.via.array.ptr[6] = object(v.template get<6>(), o.zone); + o.via.array.ptr[7] = object(v.template get<7>(), o.zone); + o.via.array.ptr[8] = object(v.template get<8>(), o.zone); + o.via.array.ptr[9] = object(v.template get<9>(), o.zone); + o.via.array.ptr[10] = object(v.template get<10>(), o.zone); + o.via.array.ptr[11] = object(v.template get<11>(), o.zone); + o.via.array.ptr[12] = object(v.template get<12>(), o.zone); + o.via.array.ptr[13] = object(v.template get<13>(), o.zone); + o.via.array.ptr[14] = object(v.template get<14>(), o.zone); + o.via.array.ptr[15] = object(v.template get<15>(), o.zone); + o.via.array.ptr[16] = object(v.template get<16>(), o.zone); + o.via.array.ptr[17] = object(v.template get<17>(), o.zone); + o.via.array.ptr[18] = object(v.template get<18>(), o.zone); + o.via.array.ptr[19] = object(v.template get<19>(), o.zone); + o.via.array.ptr[20] = object(v.template get<20>(), o.zone); + o.via.array.ptr[21] = object(v.template get<21>(), o.zone); + o.via.array.ptr[22] = object(v.template get<22>(), o.zone); + o.via.array.ptr[23] = object(v.template get<23>(), o.zone); + o.via.array.ptr[24] = object(v.template get<24>(), o.zone); + o.via.array.ptr[25] = object(v.template get<25>(), o.zone); + o.via.array.ptr[26] = object(v.template get<26>(), o.zone); + o.via.array.ptr[27] = object(v.template get<27>(), o.zone); + o.via.array.ptr[28] = object(v.template get<28>(), o.zone); + o.via.array.ptr[29] = object(v.template get<29>(), o.zone); + o.via.array.ptr[30] = object(v.template get<30>(), o.zone); + o.via.array.ptr[31] = object(v.template get<31>(), o.zone); } @@ -13127,786 +13127,786 @@ inline void operator<< ( // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << ", " << v.template get<29>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << ", " << v.template get<29>() -// << ", " << v.template get<30>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << ", " << v.template get<30>() +// << "]"; //} // //template //inline std::ostream& operator<< (std::ostream& o, -// const msgpack::type::tuple& v) { -// return o << "[" -// -// << v.template get<0>() -// << ", " << v.template get<1>() -// << ", " << v.template get<2>() -// << ", " << v.template get<3>() -// << ", " << v.template get<4>() -// << ", " << v.template get<5>() -// << ", " << v.template get<6>() -// << ", " << v.template get<7>() -// << ", " << v.template get<8>() -// << ", " << v.template get<9>() -// << ", " << v.template get<10>() -// << ", " << v.template get<11>() -// << ", " << v.template get<12>() -// << ", " << v.template get<13>() -// << ", " << v.template get<14>() -// << ", " << v.template get<15>() -// << ", " << v.template get<16>() -// << ", " << v.template get<17>() -// << ", " << v.template get<18>() -// << ", " << v.template get<19>() -// << ", " << v.template get<20>() -// << ", " << v.template get<21>() -// << ", " << v.template get<22>() -// << ", " << v.template get<23>() -// << ", " << v.template get<24>() -// << ", " << v.template get<25>() -// << ", " << v.template get<26>() -// << ", " << v.template get<27>() -// << ", " << v.template get<28>() -// << ", " << v.template get<29>() -// << ", " << v.template get<30>() -// << ", " << v.template get<31>() -// << "]"; +// const msgpack::type::tuple& v) { +// return o << "[" +// +// << v.template get<0>() +// << ", " << v.template get<1>() +// << ", " << v.template get<2>() +// << ", " << v.template get<3>() +// << ", " << v.template get<4>() +// << ", " << v.template get<5>() +// << ", " << v.template get<6>() +// << ", " << v.template get<7>() +// << ", " << v.template get<8>() +// << ", " << v.template get<9>() +// << ", " << v.template get<10>() +// << ", " << v.template get<11>() +// << ", " << v.template get<12>() +// << ", " << v.template get<13>() +// << ", " << v.template get<14>() +// << ", " << v.template get<15>() +// << ", " << v.template get<16>() +// << ", " << v.template get<17>() +// << ", " << v.template get<18>() +// << ", " << v.template get<19>() +// << ", " << v.template get<20>() +// << ", " << v.template get<21>() +// << ", " << v.template get<22>() +// << ", " << v.template get<23>() +// << ", " << v.template get<24>() +// << ", " << v.template get<25>() +// << ", " << v.template get<26>() +// << ", " << v.template get<27>() +// << ", " << v.template get<28>() +// << ", " << v.template get<29>() +// << ", " << v.template get<30>() +// << ", " << v.template get<31>() +// << "]"; //} // diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index 15a1df6d..9addb54a 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -21,46 +21,46 @@ #include #define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object const& o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - }\ - template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ - } + template \ + void msgpack_pack(Packer& pk) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ + } \ + void msgpack_unpack(msgpack::object const& o) \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ + }\ + template \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + { \ + msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ + } // MSGPACK_ADD_ENUM must be used in the global namespace. #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ - template <> \ - inline enum& operator>> (object const& o, enum& v) \ - { \ - int tmp; \ - o >> tmp; \ - v = static_cast(tmp); \ - return v; \ - } \ - template <> \ - inline void operator<< (object::with_zone& o, const enum& v) \ - { \ - int tmp = static_cast::type>(v); \ - o << tmp; \ - } \ - namespace detail { \ - template \ - struct packer_serializer { \ - static packer& pack(packer& o, const enum& v) { \ - return o << static_cast::type>(v); \ - } \ - }; \ - } \ + template <> \ + inline enum& operator>> (object const& o, enum& v) \ + { \ + int tmp; \ + o >> tmp; \ + v = static_cast(tmp); \ + return v; \ + } \ + template <> \ + inline void operator<< (object::with_zone& o, const enum& v) \ + { \ + int tmp = static_cast::type>(v); \ + o << tmp; \ + } \ + namespace detail { \ + template \ + struct packer_serializer { \ + static packer& pack(packer& o, const enum& v) { \ + return o << static_cast::type>(v); \ + } \ + }; \ + } \ } namespace msgpack { @@ -68,100 +68,100 @@ namespace type { template struct define_imp { - template - static void pack(Packer& pk, Tuple const& t) { - define_imp::pack(pk, t); - pk.pack(std::get(t)); - } - static void unpack(msgpack::object const& o, Tuple& t) { - define_imp::unpack(o, t); - const size_t size = o.via.array.size; - if(size <= N-1) { return; } - o.via.array.ptr[N-1].convert(std::get(t)); - } - static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { - define_imp::object(o, z, t); - o->via.array.ptr[N-1] = msgpack::object(std::get(t), z); - } + template + static void pack(Packer& pk, Tuple const& t) { + define_imp::pack(pk, t); + pk.pack(std::get(t)); + } + static void unpack(msgpack::object const& o, Tuple& t) { + define_imp::unpack(o, t); + const size_t size = o.via.array.size; + if(size <= N-1) { return; } + o.via.array.ptr[N-1].convert(std::get(t)); + } + static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { + define_imp::object(o, z, t); + o->via.array.ptr[N-1] = msgpack::object(std::get(t), z); + } }; template struct define_imp { - template - static void pack(Packer& pk, Tuple const& t) { - pk.pack(std::get<0>(t)); - } - static void unpack(msgpack::object const& o, Tuple& t) { - const size_t size = o.via.array.size; - if(size <= 0) { return; } - o.via.array.ptr[0].convert(std::get<0>(t)); - } - static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { - o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z); - } + template + static void pack(Packer& pk, Tuple const& t) { + pk.pack(std::get<0>(t)); + } + static void unpack(msgpack::object const& o, Tuple& t) { + const size_t size = o.via.array.size; + if(size <= 0) { return; } + o.via.array.ptr[0].convert(std::get<0>(t)); + } + static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { + o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z); + } }; template struct define { - typedef define value_type; - typedef tuple tuple_type; - define(Args&... args) : - a(args...) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(sizeof...(Args)); + typedef define value_type; + typedef tuple tuple_type; + define(Args&... args) : + a(args...) {} + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(sizeof...(Args)); - define_imp, sizeof...(Args)>::pack(pk, a); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } + define_imp, sizeof...(Args)>::pack(pk, a); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } - define_imp, sizeof...(Args)>::unpack(o, a); - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*sizeof...(Args))); - o->via.array.size = sizeof...(Args); + define_imp, sizeof...(Args)>::unpack(o, a); + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*sizeof...(Args))); + o->via.array.size = sizeof...(Args); - define_imp, sizeof...(Args)>::object(o, z, a); - } + define_imp, sizeof...(Args)>::object(o, z, a); + } - tuple a; + tuple a; }; template <> struct define<> { - typedef define<> value_type; - typedef tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(0); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != type::ARRAY) { throw type_error(); } - } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const - { - o->type = type::ARRAY; - o->via.array.ptr = NULL; - o->via.array.size = 0; - } + typedef define<> value_type; + typedef tuple<> tuple_type; + template + void msgpack_pack(Packer& pk) const + { + pk.pack_array(0); + } + void msgpack_unpack(msgpack::object const& o) + { + if(o.type != type::ARRAY) { throw type_error(); } + } + void msgpack_object(msgpack::object* o, msgpack::zone* z) const + { + o->type = type::ARRAY; + o->via.array.ptr = NULL; + o->via.array.size = 0; + } }; inline define<> make_define() { - return define<>(); + return define<>(); } template define make_define(Args&... args) { - return define(args...); + return define(args...); } } // namespace type diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 9f10ce7a..d3ae6cab 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -26,157 +26,157 @@ namespace msgpack { namespace type { - // tuple - using std::get; - using std::tuple_size; - using std::tuple_element; - using std::uses_allocator; - using std::ignore; - using std::make_tuple; - using std::tie; - using std::forward_as_tuple; - using std::swap; + // tuple + using std::get; + using std::tuple_size; + using std::tuple_element; + using std::uses_allocator; + using std::ignore; + using std::make_tuple; + using std::tie; + using std::forward_as_tuple; + using std::swap; - template< class... Types > - class tuple : public std::tuple { - public: - using base = std::tuple; + template< class... Types > + class tuple : public std::tuple { + public: + using base = std::tuple; - using base::tuple; + using base::tuple; - tuple() = default; - tuple(tuple const&) = default; - tuple(tuple&&) = default; + tuple() = default; + tuple(tuple const&) = default; + tuple(tuple&&) = default; - template - tuple(tuple const& other):base(static_cast const&>(other)) {} - template - tuple(tuple && other):base(static_cast &&>(other)) {} + template + tuple(tuple const& other):base(static_cast const&>(other)) {} + template + tuple(tuple && other):base(static_cast &&>(other)) {} - tuple& operator=(tuple const&) = default; - tuple& operator=(tuple&&) = default; + tuple& operator=(tuple const&) = default; + tuple& operator=(tuple&&) = default; - template - tuple& operator=(tuple const& other) { - *static_cast(this) = static_cast const&>(other); - return *this; - } - template - tuple& operator=(tuple && other) { - *static_cast(this) = static_cast &&>(other); - return *this; - } + template + tuple& operator=(tuple const& other) { + *static_cast(this) = static_cast const&>(other); + return *this; + } + template + tuple& operator=(tuple && other) { + *static_cast(this) = static_cast &&>(other); + return *this; + } - template< std::size_t I> - typename tuple_element::type& - get() { return std::get(*this); } + template< std::size_t I> + typename tuple_element::type& + get() { return std::get(*this); } - template< std::size_t I> - typename tuple_element::type const& - get() const { return std::get(*this); } + template< std::size_t I> + typename tuple_element::type const& + get() const { return std::get(*this); } - template< std::size_t I> - typename tuple_element::type&& - get() && { return std::get(*this); } - }; + template< std::size_t I> + typename tuple_element::type&& + get() && { return std::get(*this); } + }; - template< class... Tuples > - auto tuple_cat(Tuples&&... args) -> - decltype( - std::tuple_cat(std::forward::type::base>(args)...) - ) { - return std::tuple_cat(std::forward::type::base>(args)...); - } + template< class... Tuples > + auto tuple_cat(Tuples&&... args) -> + decltype( + std::tuple_cat(std::forward::type::base>(args)...) + ) { + return std::tuple_cat(std::forward::type::base>(args)...); + } } // namespace type // --- Pack ( from tuple to packer stream --- template struct MsgpackTuplePacker { - static void pack( - packer& o, - const Tuple& v) { - MsgpackTuplePacker::pack(o, v); - o.pack(type::get(v)); - } + static void pack( + packer& o, + const Tuple& v) { + MsgpackTuplePacker::pack(o, v); + o.pack(type::get(v)); + } }; template struct MsgpackTuplePacker { - static void pack ( - packer& o, - const Tuple& v) { - o.pack(type::get<0>(v)); - } + static void pack ( + packer& o, + const Tuple& v) { + o.pack(type::get<0>(v)); + } }; template const packer& operator<< ( - packer& o, - const type::tuple& v) { - o.pack_array(sizeof...(Args)); - MsgpackTuplePacker::pack(o, v); - return o; + packer& o, + const type::tuple& v) { + o.pack_array(sizeof...(Args)); + MsgpackTuplePacker::pack(o, v); + return o; } // --- Convert from tuple to object --- template struct MsgpackTupleConverter { - static void convert( - object const& o, - Tuple& v) { - MsgpackTupleConverter::convert(o, v); - o.via.array.ptr[N-1].convert(v))>::type>(type::get(v)); - } + static void convert( + object const& o, + Tuple& v) { + MsgpackTupleConverter::convert(o, v); + o.via.array.ptr[N-1].convert(v))>::type>(type::get(v)); + } }; template struct MsgpackTupleConverter { - static void convert ( - object const& o, - Tuple& v) { - o.via.array.ptr[0].convert(v))>::type>(type::get<0>(v)); - } + static void convert ( + object const& o, + Tuple& v) { + o.via.array.ptr[0].convert(v))>::type>(type::get<0>(v)); + } }; template type::tuple& operator>> ( - object const& o, - type::tuple& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size < sizeof...(Args)) { throw type_error(); } - MsgpackTupleConverter::convert(o, v); - return v; + object const& o, + type::tuple& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size < sizeof...(Args)) { throw type_error(); } + MsgpackTupleConverter::convert(o, v); + return v; } // --- Convert from tuple to object with zone --- template struct MsgpackTupleToObjectWithZone { - static void convert( - object::with_zone& o, - const Tuple& v) { - MsgpackTupleToObjectWithZone::convert(o, v); - o.via.array.ptr[N-1] = object(type::get(v), o.zone); - } + static void convert( + object::with_zone& o, + const Tuple& v) { + MsgpackTupleToObjectWithZone::convert(o, v); + o.via.array.ptr[N-1] = object(type::get(v), o.zone); + } }; template struct MsgpackTupleToObjectWithZone { - static void convert ( - object::with_zone& o, - const Tuple& v) { - o.via.array.ptr[0] = object(type::get<0>(v), o.zone); - } + static void convert ( + object::with_zone& o, + const Tuple& v) { + o.via.array.ptr[0] = object(type::get<0>(v), o.zone); + } }; template inline void operator<< ( - object::with_zone& o, - type::tuple& v) { - o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); - o.via.array.size = sizeof...(Args); - MsgpackTupleToObjectWithZone::convert(o, v); + object::with_zone& o, + type::tuple& v) { + o.type = type::ARRAY; + o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); + o.via.array.size = sizeof...(Args); + MsgpackTupleToObjectWithZone::convert(o, v); } } // msgpack diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp index 16380beb..6acbc132 100644 --- a/include/msgpack/adaptor/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -28,15 +28,15 @@ namespace type { template struct fix_int { - fix_int() : value(0) { } - fix_int(T value) : value(value) { } + fix_int() : value(0) { } + fix_int(T value) : value(value) { } - operator T() const { return value; } + operator T() const { return value; } - T get() const { return value; } + T get() const { return value; } private: - T value; + T value; }; @@ -55,115 +55,115 @@ typedef fix_int fix_int64; inline type::fix_int8& operator>> (object const& o, type::fix_int8& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline type::fix_int16& operator>> (object const& o, type::fix_int16& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline type::fix_int32& operator>> (object const& o, type::fix_int32& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline type::fix_int64& operator>> (object const& o, type::fix_int64& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline type::fix_uint8& operator>> (object const& o, type::fix_uint8& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline type::fix_uint16& operator>> (object const& o, type::fix_uint16& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline type::fix_uint32& operator>> (object const& o, type::fix_uint32& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline type::fix_uint64& operator>> (object const& o, type::fix_uint64& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } template inline packer& operator<< (packer& o, const type::fix_int8& v) - { o.pack_fix_int8(v); return o; } + { o.pack_fix_int8(v); return o; } template inline packer& operator<< (packer& o, const type::fix_int16& v) - { o.pack_fix_int16(v); return o; } + { o.pack_fix_int16(v); return o; } template inline packer& operator<< (packer& o, const type::fix_int32& v) - { o.pack_fix_int32(v); return o; } + { o.pack_fix_int32(v); return o; } template inline packer& operator<< (packer& o, const type::fix_int64& v) - { o.pack_fix_int64(v); return o; } + { o.pack_fix_int64(v); return o; } template inline packer& operator<< (packer& o, const type::fix_uint8& v) - { o.pack_fix_uint8(v); return o; } + { o.pack_fix_uint8(v); return o; } template inline packer& operator<< (packer& o, const type::fix_uint16& v) - { o.pack_fix_uint16(v); return o; } + { o.pack_fix_uint16(v); return o; } template inline packer& operator<< (packer& o, const type::fix_uint32& v) - { o.pack_fix_uint32(v); return o; } + { o.pack_fix_uint32(v); return o; } template inline packer& operator<< (packer& o, const type::fix_uint64& v) - { o.pack_fix_uint64(v); return o; } + { o.pack_fix_uint64(v); return o; } inline void operator<< (object& o, type::fix_int8 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object& o, type::fix_int16 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object& o, type::fix_int32 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object& o, type::fix_int64 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object& o, type::fix_uint8 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object& o, type::fix_uint16 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object& o, type::fix_uint32 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object& o, type::fix_uint64 v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } inline void operator<< (object::with_zone& o, type::fix_int8 v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, type::fix_int16 v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, type::fix_int32 v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, type::fix_int64 v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, type::fix_uint8 v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, type::fix_uint16 v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, type::fix_uint32 v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, type::fix_uint64 v) - { static_cast(o) << v; } + { static_cast(o) << v; } } // namespace msgpack diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp index 48bc1be8..b49767c4 100644 --- a/include/msgpack/adaptor/float.hpp +++ b/include/msgpack/adaptor/float.hpp @@ -29,71 +29,71 @@ namespace msgpack { inline float& operator>> (object const& o, float& v) { - if(o.type == type::DOUBLE) { - v = static_cast(o.via.dec); - } - else if (o.type == type::POSITIVE_INTEGER) { - v = static_cast(o.via.u64); - } - else if (o.type == type::NEGATIVE_INTEGER) { - v = static_cast(o.via.i64); - } - else { - throw type_error(); - } - return v; + if(o.type == type::DOUBLE) { + v = static_cast(o.via.dec); + } + else if (o.type == type::POSITIVE_INTEGER) { + v = static_cast(o.via.u64); + } + else if (o.type == type::NEGATIVE_INTEGER) { + v = static_cast(o.via.i64); + } + else { + throw type_error(); + } + return v; } template inline packer& operator<< (packer& o, const float& v) { - o.pack_float(v); - return o; + o.pack_float(v); + return o; } inline double& operator>> (object const& o, double& v) { - if(o.type == type::DOUBLE) { - v = o.via.dec; - } - else if (o.type == type::POSITIVE_INTEGER) { - v = static_cast(o.via.u64); - } - else if (o.type == type::NEGATIVE_INTEGER) { - v = static_cast(o.via.i64); - } - else { - throw type_error(); - } - return v; + if(o.type == type::DOUBLE) { + v = o.via.dec; + } + else if (o.type == type::POSITIVE_INTEGER) { + v = static_cast(o.via.u64); + } + else if (o.type == type::NEGATIVE_INTEGER) { + v = static_cast(o.via.i64); + } + else { + throw type_error(); + } + return v; } template inline packer& operator<< (packer& o, const double& v) { - o.pack_double(v); - return o; + o.pack_double(v); + return o; } inline void operator<< (object& o, float v) { - o.type = type::DOUBLE; - o.via.dec = static_cast(v); + o.type = type::DOUBLE; + o.via.dec = static_cast(v); } inline void operator<< (object& o, double v) { - o.type = type::DOUBLE; - o.via.dec = v; + o.type = type::DOUBLE; + o.via.dec = v; } inline void operator<< (object::with_zone& o, float v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, double v) - { static_cast(o) << v; } + { static_cast(o) << v; } } // namespace msgpack diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp index f1b588b6..27ae7031 100644 --- a/include/msgpack/adaptor/int.hpp +++ b/include/msgpack/adaptor/int.hpp @@ -26,251 +26,251 @@ namespace msgpack { namespace type { namespace detail { - template - struct convert_integer_sign; + template + struct convert_integer_sign; - template - struct convert_integer_sign { - static inline T convert(object const& o) { - if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > static_cast(std::numeric_limits::max())) - { throw type_error(); } - return static_cast(o.via.u64); - } else if(o.type == type::NEGATIVE_INTEGER) { - if(o.via.i64 < static_cast(std::numeric_limits::min())) - { throw type_error(); } - return static_cast(o.via.i64); - } - throw type_error(); - } - }; + template + struct convert_integer_sign { + static inline T convert(object const& o) { + if(o.type == type::POSITIVE_INTEGER) { + if(o.via.u64 > static_cast(std::numeric_limits::max())) + { throw type_error(); } + return static_cast(o.via.u64); + } else if(o.type == type::NEGATIVE_INTEGER) { + if(o.via.i64 < static_cast(std::numeric_limits::min())) + { throw type_error(); } + return static_cast(o.via.i64); + } + throw type_error(); + } + }; - template - struct convert_integer_sign { - static inline T convert(object const& o) { - if(o.type == type::POSITIVE_INTEGER) { - if(o.via.u64 > static_cast(std::numeric_limits::max())) - { throw type_error(); } - return static_cast(o.via.u64); - } - throw type_error(); - } - }; + template + struct convert_integer_sign { + static inline T convert(object const& o) { + if(o.type == type::POSITIVE_INTEGER) { + if(o.via.u64 > static_cast(std::numeric_limits::max())) + { throw type_error(); } + return static_cast(o.via.u64); + } + throw type_error(); + } + }; - template - struct is_signed { - static const bool value = std::numeric_limits::is_signed; - }; + template + struct is_signed { + static const bool value = std::numeric_limits::is_signed; + }; - template - static inline T convert_integer(object const& o) - { - return detail::convert_integer_sign::value>::convert(o); - } + template + static inline T convert_integer(object const& o) + { + return detail::convert_integer_sign::value>::convert(o); + } - template - struct pack_char_sign; + template + struct pack_char_sign; - template <> - struct pack_char_sign { - template - static inline packer& pack(packer& o, char v) { - o.pack_int8(v); return o; - } - }; + template <> + struct pack_char_sign { + template + static inline packer& pack(packer& o, char v) { + o.pack_int8(v); return o; + } + }; - template <> - struct pack_char_sign { - template - static inline packer& pack(packer& o, char v) { - o.pack_uint8(v); return o; - } - }; + template <> + struct pack_char_sign { + template + static inline packer& pack(packer& o, char v) { + o.pack_uint8(v); return o; + } + }; - template - static inline packer& pack_char(packer& o, char v) { - return pack_char_sign::value>::pack(o, v); - } + template + static inline packer& pack_char(packer& o, char v) { + return pack_char_sign::value>::pack(o, v); + } - template - struct object_char_sign; + template + struct object_char_sign; - template <> - struct object_char_sign { - static inline void make(object& o, char v) { - v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v - : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; - } - }; + template <> + struct object_char_sign { + static inline void make(object& o, char v) { + v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v + : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; + } + }; - template <> - struct object_char_sign { - static inline void make(object& o, char v) { - o.type = type::POSITIVE_INTEGER, o.via.u64 = v; - } - }; + template <> + struct object_char_sign { + static inline void make(object& o, char v) { + o.type = type::POSITIVE_INTEGER, o.via.u64 = v; + } + }; - static inline void object_char(object& o, char v) { - return object_char_sign::value>::make(o, v); - } + static inline void object_char(object& o, char v) { + return object_char_sign::value>::make(o, v); + } } // namespace detail } // namespace type inline char& operator>> (object const& o, char& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline signed char& operator>> (object const& o, signed char& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline signed short& operator>> (object const& o, signed short& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline signed int& operator>> (object const& o, signed int& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline signed long& operator>> (object const& o, signed long& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline signed long long& operator>> (object const& o, signed long long& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline unsigned char& operator>> (object const& o, unsigned char& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline unsigned short& operator>> (object const& o, unsigned short& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline unsigned int& operator>> (object const& o, unsigned int& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline unsigned long& operator>> (object const& o, unsigned long& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } inline unsigned long long& operator>> (object const& o, unsigned long long& v) - { v = type::detail::convert_integer(o); return v; } + { v = type::detail::convert_integer(o); return v; } template inline packer& operator<< (packer& o, char v) - { return type::detail::pack_char(o, v); } + { return type::detail::pack_char(o, v); } template inline packer& operator<< (packer& o, signed char v) - { o.pack_int8(v); return o; } + { o.pack_int8(v); return o; } template inline packer& operator<< (packer& o, signed short v) - { o.pack_short(v); return o; } + { o.pack_short(v); return o; } template inline packer& operator<< (packer& o, signed int v) - { o.pack_int(v); return o; } + { o.pack_int(v); return o; } template inline packer& operator<< (packer& o, signed long v) - { o.pack_long(v); return o; } + { o.pack_long(v); return o; } template inline packer& operator<< (packer& o, signed long long v) - { o.pack_long_long(v); return o; } + { o.pack_long_long(v); return o; } template inline packer& operator<< (packer& o, unsigned char v) - { o.pack_uint8(v); return o; } + { o.pack_uint8(v); return o; } template inline packer& operator<< (packer& o, unsigned short v) - { o.pack_unsigned_short(v); return o; } + { o.pack_unsigned_short(v); return o; } template inline packer& operator<< (packer& o, unsigned int v) - { o.pack_unsigned_int(v); return o; } + { o.pack_unsigned_int(v); return o; } template inline packer& operator<< (packer& o, unsigned long v) - { o.pack_unsigned_long(v); return o; } + { o.pack_unsigned_long(v); return o; } template inline packer& operator<< (packer& o, unsigned long long v) - { o.pack_unsigned_long_long(v); return o; } + { o.pack_unsigned_long_long(v); return o; } inline void operator<< (object& o, char v) - { type::detail::object_char(o, v); } + { type::detail::object_char(o, v); } inline void operator<< (object& o, signed char v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, signed short v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, signed int v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, signed long v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, signed long long v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, unsigned char v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, unsigned short v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, unsigned int v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, unsigned long v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object& o, unsigned long long v) - { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } + { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } inline void operator<< (object::with_zone& o, char v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, signed char v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, signed short v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, signed int v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, signed long v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, const signed long long& v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, unsigned char v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, unsigned short v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, unsigned int v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, unsigned long v) - { static_cast(o) << v; } + { static_cast(o) << v; } inline void operator<< (object::with_zone& o, const unsigned long long& v) - { static_cast(o) << v; } + { static_cast(o) << v; } } // namespace msgpack diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index f3ac18ba..7f5f7085 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -27,47 +27,47 @@ namespace msgpack { template inline std::list& operator>> (object const& o, std::list& v) { - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - typename std::list::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(*it); - } - return v; + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + typename std::list::iterator it = v.begin(); + for(; p < pend; ++p, ++it) { + p->convert(*it); + } + return v; } template inline packer& operator<< (packer& o, const std::list& v) { - o.pack_array(v.size()); - for(typename std::list::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; + o.pack_array(v.size()); + for(typename std::list::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; } template inline void operator<< (object::with_zone& o, const std::list& v) { - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::list::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::list::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } } diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index a4242b77..5cbb6ede 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -32,11 +32,11 @@ template class assoc_vector : public std::vector< std::pair > {}; namespace detail { - template - struct pair_first_less { - bool operator() (const std::pair& x, const std::pair& y) const - { return x.first < y.first; } - }; + template + struct pair_first_less { + bool operator() (const std::pair& x, const std::pair& y) const + { return x.first < y.first; } + }; } } //namespace type @@ -45,157 +45,157 @@ namespace detail { template inline type::assoc_vector& operator>> (object const& o, type::assoc_vector& v) { - if(o.type != type::MAP) { throw type_error(); } - v.resize(o.via.map.size); - object_kv* p = o.via.map.ptr; - object_kv* const pend = o.via.map.ptr + o.via.map.size; - std::pair* it(&v.front()); - for(; p < pend; ++p, ++it) { - p->key.convert(it->first); - p->val.convert(it->second); - } - std::sort(v.begin(), v.end(), type::detail::pair_first_less()); - return v; + if(o.type != type::MAP) { throw type_error(); } + v.resize(o.via.map.size); + object_kv* p = o.via.map.ptr; + object_kv* const pend = o.via.map.ptr + o.via.map.size; + std::pair* it(&v.front()); + for(; p < pend; ++p, ++it) { + p->key.convert(it->first); + p->val.convert(it->second); + } + std::sort(v.begin(), v.end(), type::detail::pair_first_less()); + return v; } template inline packer& operator<< (packer& o, const type::assoc_vector& v) { - o.pack_map(v.size()); - for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; + o.pack_map(v.size()); + for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; } template inline void operator<< (object::with_zone& o, const type::assoc_vector& v) { - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename type::assoc_vector::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename type::assoc_vector::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } } template inline std::map operator>> (object const& o, std::map& v) { - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - K key; - p->key.convert(key); - typename std::map::iterator it(v.lower_bound(key)); - if(it != v.end() && !(key < it->first)) { - p->val.convert(it->second); - } else { - V val; - p->val.convert(val); - v.insert(it, std::pair(key, val)); - } - } - return v; + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + for(; p != pend; ++p) { + K key; + p->key.convert(key); + typename std::map::iterator it(v.lower_bound(key)); + if(it != v.end() && !(key < it->first)) { + p->val.convert(it->second); + } else { + V val; + p->val.convert(val); + v.insert(it, std::pair(key, val)); + } + } + return v; } template inline packer& operator<< (packer& o, const std::map& v) { - o.pack_map(v.size()); - for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; + o.pack_map(v.size()); + for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; } template inline void operator<< (object::with_zone& o, const std::map& v) { - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename std::map::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename std::map::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } } template inline std::multimap operator>> (object const& o, std::multimap& v) { - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - std::pair value; - p->key.convert(value.first); - p->val.convert(value.second); - v.insert(value); - } - return v; + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + for(; p != pend; ++p) { + std::pair value; + p->key.convert(value.first); + p->val.convert(value.second); + v.insert(value); + } + return v; } template inline packer& operator<< (packer& o, const std::multimap& v) { - o.pack_map(v.size()); - for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; + o.pack_map(v.size()); + for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; } template inline void operator<< (object::with_zone& o, const std::multimap& v) { - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename std::multimap::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename std::multimap::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } } diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp index 03b9945e..bef57fc5 100644 --- a/include/msgpack/adaptor/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -31,31 +31,31 @@ struct nil { }; inline type::nil& operator>> (object const& o, type::nil& v) { - if(o.type != type::NIL) { throw type_error(); } - return v; + if(o.type != type::NIL) { throw type_error(); } + return v; } template inline packer& operator<< (packer& o, const type::nil& v) { - o.pack_nil(); - return o; + o.pack_nil(); + return o; } inline void operator<< (object& o, type::nil v) { - o.type = type::NIL; + o.type = type::NIL; } inline void operator<< (object::with_zone& o, type::nil v) - { static_cast(o) << v; } + { static_cast(o) << v; } template <> inline void object::as() const { - msgpack::type::nil v; - convert(v); + msgpack::type::nil v; + convert(v); } diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp index 266abc72..850e17f8 100644 --- a/include/msgpack/adaptor/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -27,31 +27,31 @@ namespace msgpack { template inline std::pair& operator>> (object const& o, std::pair& v) { - if(o.type != type::ARRAY) { throw type_error(); } - if(o.via.array.size != 2) { throw type_error(); } - o.via.array.ptr[0].convert(v.first); - o.via.array.ptr[1].convert(v.second); - return v; + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size != 2) { throw type_error(); } + o.via.array.ptr[0].convert(v.first); + o.via.array.ptr[1].convert(v.second); + return v; } template inline packer& operator<< (packer& o, const std::pair& v) { - o.pack_array(2); - o.pack(v.first); - o.pack(v.second); - return o; + o.pack_array(2); + o.pack(v.first); + o.pack(v.second); + return o; } template inline void operator<< (object::with_zone& o, const std::pair& v) { - o.type = type::ARRAY; - object* p = static_cast(o.zone->allocate_align(sizeof(object)*2)); - o.via.array.ptr = p; - o.via.array.size = 2; - p[0] = object(v.first, o.zone); - p[1] = object(v.second, o.zone); + o.type = type::ARRAY; + object* p = static_cast(o.zone->allocate_align(sizeof(object)*2)); + o.via.array.ptr = p; + o.via.array.size = 2; + p[0] = object(v.first, o.zone); + p[1] = object(v.second, o.zone); } diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp index 4f575f79..0d41b846 100644 --- a/include/msgpack/adaptor/raw.hpp +++ b/include/msgpack/adaptor/raw.hpp @@ -27,35 +27,35 @@ namespace msgpack { namespace type { struct raw_ref { - raw_ref() : size(0), ptr(nullptr) {} - raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {} + raw_ref() : size(0), ptr(nullptr) {} + raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {} - uint32_t size; - const char* ptr; + uint32_t size; + const char* ptr; - std::string str() const { return std::string(ptr, size); } + std::string str() const { return std::string(ptr, size); } - bool operator== (const raw_ref& x) const - { - return size == x.size && memcmp(ptr, x.ptr, size) == 0; - } + bool operator== (const raw_ref& x) const + { + return size == x.size && memcmp(ptr, x.ptr, size) == 0; + } - bool operator!= (const raw_ref& x) const - { - return !(*this != x); - } + bool operator!= (const raw_ref& x) const + { + return !(*this != x); + } - bool operator< (const raw_ref& x) const - { - if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; } - else { return size < x.size; } - } + bool operator< (const raw_ref& x) const + { + if(size == x.size) { return memcmp(ptr, x.ptr, size) < 0; } + else { return size < x.size; } + } - bool operator> (const raw_ref& x) const - { - if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; } - else { return size > x.size; } - } + bool operator> (const raw_ref& x) const + { + if(size == x.size) { return memcmp(ptr, x.ptr, size) > 0; } + else { return size > x.size; } + } }; } // namespace type @@ -63,29 +63,29 @@ struct raw_ref { inline type::raw_ref& operator>> (object const& o, type::raw_ref& v) { - if(o.type != type::BIN) { throw type_error(); } - v.ptr = o.via.bin.ptr; - v.size = o.via.bin.size; - return v; + if(o.type != type::BIN) { throw type_error(); } + v.ptr = o.via.bin.ptr; + v.size = o.via.bin.size; + return v; } template inline packer& operator<< (packer& o, const type::raw_ref& v) { - o.pack_bin(v.size); - o.pack_bin_body(v.ptr, v.size); - return o; + o.pack_bin(v.size); + o.pack_bin_body(v.ptr, v.size); + return o; } inline void operator<< (object& o, const type::raw_ref& v) { - o.type = type::BIN; - o.via.bin.ptr = v.ptr; - o.via.bin.size = v.size; + o.type = type::BIN; + o.via.bin.ptr = v.ptr; + o.via.bin.size = v.size; } inline void operator<< (object::with_zone& o, const type::raw_ref& v) - { static_cast(o) << v; } + { static_cast(o) << v; } } // namespace msgpack diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index cfb6e79a..098949d9 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -27,92 +27,92 @@ namespace msgpack { template inline std::set& operator>> (object const& o, std::set& v) { - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + while(p > pbegin) { + --p; + v.insert(p->as()); + } + return v; } template inline packer& operator<< (packer& o, const std::set& v) { - o.pack_array(v.size()); - for(typename std::set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; + o.pack_array(v.size()); + for(typename std::set::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; } template inline void operator<< (object::with_zone& o, const std::set& v) { - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::set::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::set::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } } template inline std::multiset& operator>> (object const& o, std::multiset& v) { - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + while(p > pbegin) { + --p; + v.insert(p->as()); + } + return v; } template inline packer& operator<< (packer& o, const std::multiset& v) { - o.pack_array(v.size()); - for(typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; + o.pack_array(v.size()); + for(typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; } template inline void operator<< (object::with_zone& o, const std::multiset& v) { - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::multiset::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::multiset::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } } diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp index 5f99fe58..38b7660a 100644 --- a/include/msgpack/adaptor/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -26,42 +26,42 @@ namespace msgpack { inline std::string& operator>> (object const& o, std::string& v) { - switch (o.type) { - case type::BIN: - v.assign(o.via.bin.ptr, o.via.bin.size); - break; - case type::STR: - v.assign(o.via.str.ptr, o.via.str.size); - break; - default: - throw type_error(); - break; - } - return v; + switch (o.type) { + case type::BIN: + v.assign(o.via.bin.ptr, o.via.bin.size); + break; + case type::STR: + v.assign(o.via.str.ptr, o.via.str.size); + break; + default: + throw type_error(); + break; + } + return v; } template inline packer& operator<< (packer& o, const std::string& v) { - o.pack_str(v.size()); - o.pack_str_body(v.data(), v.size()); - return o; + o.pack_str(v.size()); + o.pack_str_body(v.data(), v.size()); + return o; } inline void operator<< (object::with_zone& o, const std::string& v) { - o.type = type::STR; - char* ptr = static_cast(o.zone->allocate_align(v.size())); - o.via.str.ptr = ptr; - o.via.str.size = static_cast(v.size()); - memcpy(ptr, v.data(), v.size()); + o.type = type::STR; + char* ptr = static_cast(o.zone->allocate_align(v.size())); + o.via.str.ptr = ptr; + o.via.str.size = static_cast(v.size()); + memcpy(ptr, v.data(), v.size()); } inline void operator<< (object& o, const std::string& v) { - o.type = type::STR; - o.via.str.ptr = v.data(); - o.via.str.size = static_cast(v.size()); + o.type = type::STR; + o.via.str.ptr = v.data(); + o.via.str.size = static_cast(v.size()); } diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 830561cb..7d8a18e8 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -46,99 +46,99 @@ namespace msgpack { template inline MSGPACK_STD_TR1::unordered_map operator>> (object o, MSGPACK_STD_TR1::unordered_map& v) { - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - K key; - p->key.convert(key); - p->val.convert(v[key]); - } - return v; + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + for(; p != pend; ++p) { + K key; + p->key.convert(key); + p->val.convert(v[key]); + } + return v; } template inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_map& v) { - o.pack_map(v.size()); - for(typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; + o.pack_map(v.size()); + for(typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; } template inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v) { - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } } template inline MSGPACK_STD_TR1::unordered_multimap operator>> (object o, MSGPACK_STD_TR1::unordered_multimap& v) { - if(o.type != type::MAP) { throw type_error(); } - object_kv* p(o.via.map.ptr); - object_kv* const pend(o.via.map.ptr + o.via.map.size); - for(; p != pend; ++p) { - std::pair value; - p->key.convert(value.first); - p->val.convert(value.second); - v.insert(value); - } - return v; + if(o.type != type::MAP) { throw type_error(); } + object_kv* p(o.via.map.ptr); + object_kv* const pend(o.via.map.ptr + o.via.map.size); + for(; p != pend; ++p) { + std::pair value; + p->key.convert(value.first); + p->val.convert(value.second); + v.insert(value); + } + return v; } template inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multimap& v) { - o.pack_map(v.size()); - for(typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; + o.pack_map(v.size()); + for(typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(it->first); + o.pack(it->second); + } + return o; } template inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v) { - o.type = type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); - object_kv* const pend = p + v.size(); - o.via.map.ptr = p; - o.via.map.size = v.size(); - typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()); - do { - p->key = object(it->first, o.zone); - p->val = object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::MAP; + if(v.empty()) { + o.via.map.ptr = nullptr; + o.via.map.size = 0; + } else { + object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* const pend = p + v.size(); + o.via.map.ptr = p; + o.via.map.size = v.size(); + typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()); + do { + p->key = object(it->first, o.zone); + p->val = object(it->second, o.zone); + ++p; + ++it; + } while(p < pend); + } } diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index c2b2ce8e..13ae5e51 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -45,92 +45,92 @@ namespace msgpack { template inline MSGPACK_STD_TR1::unordered_set& operator>> (object o, MSGPACK_STD_TR1::unordered_set& v) { - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + while(p > pbegin) { + --p; + v.insert(p->as()); + } + return v; } template inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_set& v) { - o.pack_array(v.size()); - for(typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; + o.pack_array(v.size()); + for(typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; } template inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v) { - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } } template inline MSGPACK_STD_TR1::unordered_multiset& operator>> (object o, MSGPACK_STD_TR1::unordered_multiset& v) { - if(o.type != type::ARRAY) { throw type_error(); } - object* p = o.via.array.ptr + o.via.array.size; - object* const pbegin = o.via.array.ptr; - while(p > pbegin) { - --p; - v.insert(p->as()); - } - return v; + if(o.type != type::ARRAY) { throw type_error(); } + object* p = o.via.array.ptr + o.via.array.size; + object* const pbegin = o.via.array.ptr; + while(p > pbegin) { + --p; + v.insert(p->as()); + } + return v; } template inline packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multiset& v) { - o.pack_array(v.size()); - for(typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; + o.pack_array(v.size()); + for(typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; } template inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v) { - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } } diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index ac01b3c5..f33920fb 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -27,51 +27,51 @@ namespace msgpack { template inline std::vector& operator>> (object const& o, std::vector& v) { - if(o.type != type::ARRAY) { throw type_error(); } - v.resize(o.via.array.size); - if(o.via.array.size > 0) { - object* p = o.via.array.ptr; - object* const pend = o.via.array.ptr + o.via.array.size; - T* it = &v[0]; - do { - p->convert(*it); - ++p; - ++it; - } while(p < pend); - } - return v; + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + if(o.via.array.size > 0) { + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + T* it = &v[0]; + do { + p->convert(*it); + ++p; + ++it; + } while(p < pend); + } + return v; } template inline packer& operator<< (packer& o, const std::vector& v) { - o.pack_array(v.size()); - for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; + o.pack_array(v.size()); + for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); + it != it_end; ++it) { + o.pack(*it); + } + return o; } template inline void operator<< (object::with_zone& o, const std::vector& v) { - o.type = type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); - object* const pend = p + v.size(); - o.via.array.ptr = p; - o.via.array.size = v.size(); - typename std::vector::const_iterator it(v.begin()); - do { - *p = object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* const pend = p + v.size(); + o.via.array.ptr = p; + o.via.array.size = v.size(); + typename std::vector::const_iterator it(v.begin()); + do { + *p = object(*it, o.zone); + ++p; + ++it; + } while(p < pend); + } } diff --git a/include/msgpack/cpp_config.hpp b/include/msgpack/cpp_config.hpp index e088a3d5..72be9817 100644 --- a/include/msgpack/cpp_config.hpp +++ b/include/msgpack/cpp_config.hpp @@ -42,27 +42,27 @@ namespace msgpack { template struct unique_ptr : std::auto_ptr { - explicit unique_ptr(T* p = 0) throw() : std::auto_ptr(p) {} - unique_ptr(unique_ptr& a) throw() : std::auto_ptr(a) {} - template - unique_ptr (unique_ptr& a) throw() : std::auto_ptr(a) {} + explicit unique_ptr(T* p = 0) throw() : std::auto_ptr(p) {} + unique_ptr(unique_ptr& a) throw() : std::auto_ptr(a) {} + template + unique_ptr (unique_ptr& a) throw() : std::auto_ptr(a) {} }; template T& move(T& t) { - return t; + return t; } template T const& move(T const& t) { - return t; + return t; } template struct enable_if { - typedef T type; + typedef T type; }; template @@ -78,15 +78,15 @@ struct enable_if { #include namespace msgpack { - // unique_ptr - using std::unique_ptr; - // using std::make_unique; // since C++14 - using std::hash; + // unique_ptr + using std::unique_ptr; + // using std::make_unique; // since C++14 + using std::hash; - // utility - using std::move; - using std::swap; - using std::enable_if; + // utility + using std::move; + using std::swap; + using std::enable_if; } // msgpack diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index fdd8aa43..9e6471b9 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -3,17 +3,17 @@ // // Copyright (C) 2008-2010 FURUHASHI Sadayuki // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at // -// http://www.apache.org/licenses/LICENSE-2.0 +// http://www.apache.org/licenses/LICENSE-2.0 // -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. // #ifndef MSGPACK_CPP03_ZONE_HPP #define MSGPACK_CPP03_ZONE_HPP @@ -36,227 +36,227 @@ namespace msgpack { class zone { - struct finalizer { - finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} - void operator()() { m_func(m_data); } - void (*m_func)(void*); - void* m_data; - }; - struct finalizer_array { - finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} - void call() { - finalizer* fin = m_tail; - for(; fin != m_array; --fin) (*(fin-1))(); - } - ~finalizer_array() { - call(); - ::free(m_array); - } - void clear() { - call(); - m_tail = m_array; - } - void push(void (*func)(void* data), void* data) - { - finalizer* fin = m_tail; + struct finalizer { + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; + }; + struct finalizer_array { + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} + void call() { + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(m_array); + } + void clear() { + call(); + m_tail = m_array; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = m_tail; - if(fin == m_end) { - push_expand(func, data); - return; - } + if(fin == m_end) { + push_expand(func, data); + return; + } - fin->m_func = func; - fin->m_data = data; + fin->m_func = func; + fin->m_data = data; - ++m_tail; - } - void push_expand(void (*func)(void*), void* data) { - const size_t nused = m_end - m_array; - size_t nnext; - if(nused == 0) { - nnext = (sizeof(finalizer) < 72/2) ? - 72 / sizeof(finalizer) : 8; - } else { - nnext = nused * 2; - } - finalizer* tmp = - static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); - if(!tmp) { - throw std::bad_alloc(); - } - m_array = tmp; - m_end = tmp + nnext; - m_tail = tmp + nused; - new (m_tail) finalizer(func, data); + ++m_tail; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = m_end - m_array; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); - ++m_tail; - } - finalizer* m_tail; - finalizer* m_end; - finalizer* m_array; - }; - struct chunk { - chunk* m_next; - }; - struct chunk_list { - chunk_list(size_t chunk_size) - { - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - throw std::bad_alloc(); - } + ++m_tail; + } + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; + }; + struct chunk { + chunk* m_next; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } - m_head = c; - m_free = chunk_size; - m_ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = nullptr; - } - ~chunk_list() - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - ::free(c); - if(n) { - c = n; - } else { - break; - } - } - } - void clear(size_t chunk_size) - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - if(n) { - ::free(c); - c = n; - } else { - break; - } - } - m_head->m_next = nullptr; - m_free = chunk_size; - m_ptr = reinterpret_cast(m_head) + sizeof(chunk); - } - size_t m_free; - char* m_ptr; - chunk* m_head; - }; - size_t m_chunk_size; - chunk_list m_chunk_list; - finalizer_array m_finalizer_array; + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; + } + ~chunk_list() + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + ::free(c); + if(n) { + c = n; + } else { + break; + } + } + } + void clear(size_t chunk_size) + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + if(n) { + ::free(c); + c = n; + } else { + break; + } + } + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); + } + size_t m_free; + char* m_ptr; + chunk* m_head; + }; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; public: - static zone* create(size_t chunk_size); - static void destroy(zone* zone); - void* allocate_align(size_t size); - void* allocate_no_align(size_t size); + static zone* create(size_t chunk_size); + static void destroy(zone* zone); + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); - void push_finalizer(void (*func)(void*), void* data); + void push_finalizer(void (*func)(void*), void* data); - template - void push_finalizer(msgpack::unique_ptr obj); + template + void push_finalizer(msgpack::unique_ptr obj); - void clear(); + void clear(); - void swap(zone& o); - static void* operator new(std::size_t size) throw(std::bad_alloc) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) throw() - { - ::free(p); - } - static void* operator new(std::size_t size, void* place) throw() - { - return ::operator new(size, place); - } - static void operator delete(void* p, void* place) throw() - { - ::operator delete(p, place); - } - - template - T* allocate(); - - template - T* allocate(A1 a1); - - template - T* allocate(A1 a1, A2 a2); - - template - T* allocate(A1 a1, A2 a2, A3 a3); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12); - - template - T* allocate(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); - - template - T* allocate(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); - - template - T* allocate(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); - + void swap(zone& o); + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t size, void* place) throw() + { + return ::operator new(size, place); + } + static void operator delete(void* p, void* place) throw() + { + ::operator delete(p, place); + } + + template + T* allocate(); + + template + T* allocate(A1 a1); + + template + T* allocate(A1 a1, A2 a2); + + template + T* allocate(A1 a1, A2 a2, A3 a3); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11); + + template + T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12); + + template + T* allocate(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); + + template + T* allocate(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); + + template + T* allocate(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); + private: - void undo_allocate(size_t size); + void undo_allocate(size_t size); - template - static void object_destructor(void* obj); + template + static void object_destructor(void* obj); - void* allocate_expand(size_t size); + void* allocate_expand(size_t size); }; inline zone* zone::create(size_t chunk_size) { - zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); - if (!z) { - return nullptr; - } - new (z) zone(chunk_size); - return z; + zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); + if (!z) { + return nullptr; + } + new (z) zone(chunk_size); + return z; } inline void zone::destroy(zone* z) { - z->~zone(); - ::free(z); + z->~zone(); + ::free(z); } inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) @@ -265,383 +265,383 @@ inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_ inline void* zone::allocate_align(size_t size) { - return allocate_no_align( - ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); + return allocate_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } inline void* zone::allocate_no_align(size_t size) { - if(m_chunk_list.m_free < size) { - return allocate_expand(size); - } + if(m_chunk_list.m_free < size) { + return allocate_expand(size); + } - char* ptr = m_chunk_list.m_ptr; - m_chunk_list.m_free -= size; - m_chunk_list.m_ptr += size; + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; - return ptr; + return ptr; } inline void* zone::allocate_expand(size_t size) { - chunk_list* const cl = &m_chunk_list; + chunk_list* const cl = &m_chunk_list; - size_t sz = m_chunk_size; + size_t sz = m_chunk_size; - while(sz < size) { - sz *= 2; - } + while(sz < size) { + sz *= 2; + } - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - char* ptr = reinterpret_cast(c) + sizeof(chunk); + char* ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = cl->m_head; - cl->m_head = c; - cl->m_free = sz - size; - cl->m_ptr = ptr + size; + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; - return ptr; + return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - m_finalizer_array.push(func, data); + m_finalizer_array.push(func, data); } template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - m_finalizer_array.push(&zone::object_destructor, obj.get()); - obj.release(); + m_finalizer_array.push(&zone::object_destructor, obj.get()); + obj.release(); } inline void zone::clear() { - m_finalizer_array.clear(); - m_chunk_list.clear(m_chunk_size); + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); } inline void zone::swap(zone& o) { - std::swap(*this, o); + std::swap(*this, o); } template void zone::object_destructor(void* obj) { - reinterpret_cast(obj)->~T(); + reinterpret_cast(obj)->~T(); } inline void zone::undo_allocate(size_t size) { - m_chunk_list.m_ptr -= size; - m_chunk_list.m_free += size; + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; } template T* zone::allocate() { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(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) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(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) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } template T* zone::allocate(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) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } diff --git a/include/msgpack/detail/cpp11_zone.hpp b/include/msgpack/detail/cpp11_zone.hpp index 0164b6c0..73d7d79f 100644 --- a/include/msgpack/detail/cpp11_zone.hpp +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -36,182 +36,182 @@ namespace msgpack { class zone { private: - struct finalizer { - finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} - void operator()() { m_func(m_data); } - void (*m_func)(void*); - void* m_data; - }; - struct finalizer_array { - finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} - void call() { - finalizer* fin = m_tail; - for(; fin != m_array; --fin) (*(fin-1))(); - } - ~finalizer_array() { - call(); - ::free(m_array); - } - void clear() { - call(); - m_tail = m_array; - } - void push(void (*func)(void* data), void* data) - { - finalizer* fin = m_tail; + struct finalizer { + finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} + void operator()() { m_func(m_data); } + void (*m_func)(void*); + void* m_data; + }; + struct finalizer_array { + finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} + void call() { + finalizer* fin = m_tail; + for(; fin != m_array; --fin) (*(fin-1))(); + } + ~finalizer_array() { + call(); + ::free(m_array); + } + void clear() { + call(); + m_tail = m_array; + } + void push(void (*func)(void* data), void* data) + { + finalizer* fin = m_tail; - if(fin == m_end) { - push_expand(func, data); - return; - } + if(fin == m_end) { + push_expand(func, data); + return; + } - fin->m_func = func; - fin->m_data = data; + fin->m_func = func; + fin->m_data = data; - ++m_tail; - } - void push_expand(void (*func)(void*), void* data) { - const size_t nused = m_end - m_array; - size_t nnext; - if(nused == 0) { - nnext = (sizeof(finalizer) < 72/2) ? - 72 / sizeof(finalizer) : 8; - } else { - nnext = nused * 2; - } - finalizer* tmp = - static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); - if(!tmp) { - throw std::bad_alloc(); - } - m_array = tmp; - m_end = tmp + nnext; - m_tail = tmp + nused; - new (m_tail) finalizer(func, data); + ++m_tail; + } + void push_expand(void (*func)(void*), void* data) { + const size_t nused = m_end - m_array; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(finalizer) < 72/2) ? + 72 / sizeof(finalizer) : 8; + } else { + nnext = nused * 2; + } + finalizer* tmp = + static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); + if(!tmp) { + throw std::bad_alloc(); + } + m_array = tmp; + m_end = tmp + nnext; + m_tail = tmp + nused; + new (m_tail) finalizer(func, data); - ++m_tail; - } - finalizer* m_tail; - finalizer* m_end; - finalizer* m_array; - }; - struct chunk { - chunk* m_next; - }; - struct chunk_list { - chunk_list(size_t chunk_size) - { - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - throw std::bad_alloc(); - } + ++m_tail; + } + finalizer* m_tail; + finalizer* m_end; + finalizer* m_array; + }; + struct chunk { + chunk* m_next; + }; + struct chunk_list { + chunk_list(size_t chunk_size) + { + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + throw std::bad_alloc(); + } - m_head = c; - m_free = chunk_size; - m_ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = nullptr; - } - ~chunk_list() - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - ::free(c); - if(n) { - c = n; - } else { - break; - } - } - } - void clear(size_t chunk_size) - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - if(n) { - ::free(c); - c = n; - } else { - m_head = c; - break; - } - } - m_head->m_next = nullptr; - m_free = chunk_size; - m_ptr = reinterpret_cast(m_head) + sizeof(chunk); - } - size_t m_free; - char* m_ptr; - chunk* m_head; - }; - size_t m_chunk_size; - chunk_list m_chunk_list; - finalizer_array m_finalizer_array; + m_head = c; + m_free = chunk_size; + m_ptr = reinterpret_cast(c) + sizeof(chunk); + c->m_next = nullptr; + } + ~chunk_list() + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + ::free(c); + if(n) { + c = n; + } else { + break; + } + } + } + void clear(size_t chunk_size) + { + chunk* c = m_head; + while(true) { + chunk* n = c->m_next; + if(n) { + ::free(c); + c = n; + } else { + m_head = c; + break; + } + } + m_head->m_next = nullptr; + m_free = chunk_size; + m_ptr = reinterpret_cast(m_head) + sizeof(chunk); + } + size_t m_free; + char* m_ptr; + chunk* m_head; + }; + size_t m_chunk_size; + chunk_list m_chunk_list; + finalizer_array m_finalizer_array; public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; + zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; public: - static zone* create(size_t chunk_size); - static void destroy(zone* zone); - void* allocate_align(size_t size); - void* allocate_no_align(size_t size); + static zone* create(size_t chunk_size); + static void destroy(zone* zone); + void* allocate_align(size_t size); + void* allocate_no_align(size_t size); - void push_finalizer(void (*func)(void*), void* data); + void push_finalizer(void (*func)(void*), void* data); - template - void push_finalizer(msgpack::unique_ptr obj); + template + void push_finalizer(msgpack::unique_ptr obj); - void clear(); + void clear(); - void swap(zone& o); + void swap(zone& o); - static void* operator new(std::size_t size) throw(std::bad_alloc) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) throw() - { - ::free(p); - } - static void* operator new(std::size_t size, void* mem) throw() - { - return mem; - } - static void operator delete(void *p, void* mem) throw() - { - } + static void* operator new(std::size_t size) throw(std::bad_alloc) + { + void* p = ::malloc(size); + if (!p) throw std::bad_alloc(); + return p; + } + static void operator delete(void *p) throw() + { + ::free(p); + } + static void* operator new(std::size_t size, void* mem) throw() + { + return mem; + } + static void operator delete(void *p, void* mem) throw() + { + } - template - T* allocate(Args... args); + template + T* allocate(Args... args); private: - void undo_allocate(size_t size); + void undo_allocate(size_t size); - template - static void object_destructor(void* obj); + template + static void object_destructor(void* obj); - void* allocate_expand(size_t size); + void* allocate_expand(size_t size); }; inline zone* zone::create(size_t chunk_size) { - zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); - if (!z) { - return nullptr; - } - new (z) zone(chunk_size); - return z; + zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); + if (!z) { + return nullptr; + } + new (z) zone(chunk_size); + return z; } inline void zone::destroy(zone* z) { - z->~zone(); - ::free(z); + z->~zone(); + ::free(z); } inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) @@ -220,99 +220,99 @@ inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_ inline void* zone::allocate_align(size_t size) { - return allocate_no_align( - ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); + return allocate_no_align( + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } inline void* zone::allocate_no_align(size_t size) { - if(m_chunk_list.m_free < size) { - return allocate_expand(size); - } + if(m_chunk_list.m_free < size) { + return allocate_expand(size); + } - char* ptr = m_chunk_list.m_ptr; - m_chunk_list.m_free -= size; - m_chunk_list.m_ptr += size; + char* ptr = m_chunk_list.m_ptr; + m_chunk_list.m_free -= size; + m_chunk_list.m_ptr += size; - return ptr; + return ptr; } inline void* zone::allocate_expand(size_t size) { - chunk_list* const cl = &m_chunk_list; + chunk_list* const cl = &m_chunk_list; - size_t sz = m_chunk_size; + size_t sz = m_chunk_size; - while(sz < size) { - sz *= 2; - } + while(sz < size) { + sz *= 2; + } - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - if (!c) return nullptr; + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if (!c) return nullptr; - char* ptr = reinterpret_cast(c) + sizeof(chunk); + char* ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = cl->m_head; - cl->m_head = c; - cl->m_free = sz - size; - cl->m_ptr = ptr + size; + c->m_next = cl->m_head; + cl->m_head = c; + cl->m_free = sz - size; + cl->m_ptr = ptr + size; - return ptr; + return ptr; } inline void zone::push_finalizer(void (*func)(void*), void* data) { - m_finalizer_array.push(func, data); + m_finalizer_array.push(func, data); } template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - m_finalizer_array.push(&zone::object_destructor, obj.get()); - obj.release(); + m_finalizer_array.push(&zone::object_destructor, obj.get()); + obj.release(); } inline void zone::clear() { - m_finalizer_array.clear(); - m_chunk_list.clear(m_chunk_size); + m_finalizer_array.clear(); + m_chunk_list.clear(m_chunk_size); } inline void zone::swap(zone& o) { - std::swap(*this, o); + std::swap(*this, o); } template void zone::object_destructor(void* obj) { - reinterpret_cast(obj)->~T(); + reinterpret_cast(obj)->~T(); } inline void zone::undo_allocate(size_t size) { - m_chunk_list.m_ptr -= size; - m_chunk_list.m_free += size; + m_chunk_list.m_ptr -= size; + m_chunk_list.m_free += size; } template T* zone::allocate(Args... args) { - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destructor, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(args...); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } + void* x = allocate_align(sizeof(T)); + try { + m_finalizer_array.push(&zone::object_destructor, x); + } catch (...) { + undo_allocate(sizeof(T)); + throw; + } + try { + return new (x) T(args...); + } catch (...) { + --m_finalizer_array.m_tail; + undo_allocate(sizeof(T)); + throw; + } } } // namespace msgpack diff --git a/include/msgpack/fbuffer.h b/include/msgpack/fbuffer.h index 352f7269..85d62b03 100644 --- a/include/msgpack/fbuffer.h +++ b/include/msgpack/fbuffer.h @@ -33,7 +33,7 @@ extern "C" { static inline int msgpack_fbuffer_write(void* data, const char* buf, unsigned int len) { - return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; + return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; } /** @} */ diff --git a/include/msgpack/fbuffer.hpp b/include/msgpack/fbuffer.hpp index 548ef0bf..5d974d6f 100644 --- a/include/msgpack/fbuffer.hpp +++ b/include/msgpack/fbuffer.hpp @@ -26,27 +26,27 @@ namespace msgpack { class fbuffer { public: - explicit fbuffer(FILE* file) : m_file(file) { } + explicit fbuffer(FILE* file) : m_file(file) { } public: - void write(const char* buf, unsigned int len) - { - if (1 != fwrite(buf, len, 1, m_file)) { - throw std::runtime_error("fwrite() failed"); - } - } + void write(const char* buf, unsigned int len) + { + if (1 != fwrite(buf, len, 1, m_file)) { + throw std::runtime_error("fwrite() failed"); + } + } - FILE* file() const - { - return m_file; - } + FILE* file() const + { + return m_file; + } private: - fbuffer(const fbuffer&); - fbuffer& operator= (const fbuffer&); + fbuffer(const fbuffer&); + fbuffer& operator= (const fbuffer&); private: - FILE* m_file; + FILE* m_file; }; diff --git a/include/msgpack/object.h b/include/msgpack/object.h index 1f56c877..79859db2 100644 --- a/include/msgpack/object.h +++ b/include/msgpack/object.h @@ -33,15 +33,15 @@ extern "C" { */ typedef enum { - MSGPACK_OBJECT_NIL = 0x00, - MSGPACK_OBJECT_BOOLEAN = 0x01, - MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, - MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, - MSGPACK_OBJECT_DOUBLE = 0x04, - MSGPACK_OBJECT_STR = 0x05, - MSGPACK_OBJECT_ARRAY = 0x06, - MSGPACK_OBJECT_MAP = 0x07, - MSGPACK_OBJECT_BIN = 0x08 + MSGPACK_OBJECT_NIL = 0x00, + MSGPACK_OBJECT_BOOLEAN = 0x01, + MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, + MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, + MSGPACK_OBJECT_DOUBLE = 0x04, + MSGPACK_OBJECT_STR = 0x05, + MSGPACK_OBJECT_ARRAY = 0x06, + MSGPACK_OBJECT_MAP = 0x07, + MSGPACK_OBJECT_BIN = 0x08 } msgpack_object_type; @@ -49,44 +49,44 @@ struct msgpack_object; struct msgpack_object_kv; typedef struct { - uint32_t size; - struct msgpack_object* ptr; + uint32_t size; + struct msgpack_object* ptr; } msgpack_object_array; typedef struct { - uint32_t size; - struct msgpack_object_kv* ptr; + uint32_t size; + struct msgpack_object_kv* ptr; } msgpack_object_map; typedef struct { - uint32_t size; - const char* ptr; + uint32_t size; + const char* ptr; } msgpack_object_str; typedef struct { - uint32_t size; - const char* ptr; + uint32_t size; + const char* ptr; } msgpack_object_bin; typedef union { - bool boolean; - uint64_t u64; - int64_t i64; - double dec; - msgpack_object_array array; - msgpack_object_map map; - msgpack_object_str str; - msgpack_object_bin bin; + bool boolean; + uint64_t u64; + int64_t i64; + double dec; + msgpack_object_array array; + msgpack_object_map map; + msgpack_object_str str; + msgpack_object_bin bin; } msgpack_object_union; typedef struct msgpack_object { - msgpack_object_type type; - msgpack_object_union via; + msgpack_object_type type; + msgpack_object_union via; } msgpack_object; typedef struct msgpack_object_kv { - msgpack_object key; - msgpack_object val; + msgpack_object key; + msgpack_object val; } msgpack_object_kv; diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index a5d5bb80..fdd9a53b 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -34,17 +34,17 @@ class type_error : public std::bad_cast { }; namespace type { - enum object_type { - NIL = MSGPACK_OBJECT_NIL, - BOOLEAN = MSGPACK_OBJECT_BOOLEAN, - POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, - NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, - DOUBLE = MSGPACK_OBJECT_DOUBLE, - STR = MSGPACK_OBJECT_STR, - BIN = MSGPACK_OBJECT_BIN, - ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP - }; + enum object_type { + NIL = MSGPACK_OBJECT_NIL, + BOOLEAN = MSGPACK_OBJECT_BOOLEAN, + POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, + NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, + DOUBLE = MSGPACK_OBJECT_DOUBLE, + STR = MSGPACK_OBJECT_STR, + BIN = MSGPACK_OBJECT_BIN, + ARRAY = MSGPACK_OBJECT_ARRAY, + MAP = MSGPACK_OBJECT_MAP + }; } @@ -52,95 +52,95 @@ struct object; struct object_kv; struct object_array { - uint32_t size; - object* ptr; + uint32_t size; + object* ptr; }; struct object_map { - uint32_t size; - object_kv* ptr; + uint32_t size; + object_kv* ptr; }; struct object_str { - uint32_t size; - const char* ptr; + uint32_t size; + const char* ptr; }; struct object_bin { - uint32_t size; - const char* ptr; + uint32_t size; + const char* ptr; }; struct object { - union union_type { - bool boolean; - uint64_t u64; - int64_t i64; - double dec; - object_array array; - object_map map; - object_str str; - object_bin bin; - }; + union union_type { + bool boolean; + uint64_t u64; + int64_t i64; + double dec; + object_array array; + object_map map; + object_str str; + object_bin bin; + }; - type::object_type type; - union_type via; + type::object_type type; + union_type via; - bool is_nil() const { return type == type::NIL; } + bool is_nil() const { return type == type::NIL; } - template - T as() const; + template + T as() const; - template - void convert(T& v) const; - template - void convert(T* v) const; + template + void convert(T& v) const; + template + void convert(T* v) const; - object(); + object(); - object(msgpack_object o); + object(msgpack_object o); - template - explicit object(const T& v); + template + explicit object(const T& v); - template - object(const T& v, zone* z); + template + object(const T& v, zone* z); - template - object& operator=(const T& v); + template + object& operator=(const T& v); - operator msgpack_object() const; + operator msgpack_object() const; - struct with_zone; + struct with_zone; private: - struct implicit_type; + struct implicit_type; public: - implicit_type convert() const; + implicit_type convert() const; }; struct object_kv { - object key; - object val; + object key; + object val; }; struct object::with_zone : object { - with_zone(msgpack::zone* zone) : zone(zone) { } - msgpack::zone* zone; + with_zone(msgpack::zone* zone) : zone(zone) { } + msgpack::zone* zone; private: - with_zone(); + with_zone(); }; struct object::implicit_type { - implicit_type(object const& o) : obj(o) { } - ~implicit_type() { } + implicit_type(object const& o) : obj(o) { } + ~implicit_type() { } - template - operator T() { return obj.as(); } + template + operator T() { return obj.as(); } private: - object const& obj; + object const& obj; }; @@ -148,22 +148,22 @@ private: template class define : public Type { public: - typedef Type msgpack_type; - typedef define define_type; + typedef Type msgpack_type; + typedef define define_type; - define() {} - define(const msgpack_type& v) : msgpack_type(v) {} + define() {} + define(const msgpack_type& v) : msgpack_type(v) {} - template - void msgpack_pack(Packer& o) const - { - o << static_cast(*this); - } + template + void msgpack_pack(Packer& o) const + { + o << static_cast(*this); + } - void msgpack_unpack(object const& o) - { - o >> static_cast(*this); - } + void msgpack_unpack(object const& o) + { + o >> static_cast(*this); + } }; @@ -171,31 +171,31 @@ template template inline packer& packer::pack(const T& v) { - *this << v; - return *this; + *this << v; + return *this; } inline object& operator>> (object const& o, object& v) { - v = o; - return v; + v = o; + return v; } // convert operator template inline T& operator>> (object const& o, T& v) { - v.msgpack_unpack(o.convert()); - return v; + v.msgpack_unpack(o.convert()); + return v; } namespace detail { template struct packer_serializer { - static packer& pack(packer& o, const T& v) { - v.msgpack_pack(o); - return o; - } + static packer& pack(packer& o, const T& v) { + v.msgpack_pack(o); + return o; + } }; } @@ -203,94 +203,94 @@ struct packer_serializer { template inline packer& operator<< (packer& o, const T& v) { - return detail::packer_serializer::pack(o, v); + return detail::packer_serializer::pack(o, v); } // deconvert operator template inline void operator<< (object::with_zone& o, const T& v) { - v.msgpack_object(static_cast(&o), o.zone); + v.msgpack_object(static_cast(&o), o.zone); } inline bool operator==(const object& x, const object& y) { - if(x.type != y.type) { return false; } + if(x.type != y.type) { return false; } - switch(x.type) { - case type::NIL: - return true; + switch(x.type) { + case type::NIL: + return true; - case type::BOOLEAN: - return x.via.boolean == y.via.boolean; + case type::BOOLEAN: + return x.via.boolean == y.via.boolean; - case type::POSITIVE_INTEGER: - return x.via.u64 == y.via.u64; + case type::POSITIVE_INTEGER: + return x.via.u64 == y.via.u64; - case type::NEGATIVE_INTEGER: - return x.via.i64 == y.via.i64; + case type::NEGATIVE_INTEGER: + return x.via.i64 == y.via.i64; - case type::DOUBLE: - return x.via.dec == y.via.dec; + case type::DOUBLE: + return x.via.dec == y.via.dec; - case type::STR: - return x.via.str.size == y.via.str.size && - memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; + case type::STR: + return x.via.str.size == y.via.str.size && + memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; - case type::BIN: - return x.via.bin.size == y.via.bin.size && - memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + case type::BIN: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; - case type::ARRAY: - if(x.via.array.size != y.via.array.size) { - return false; - } else if(x.via.array.size == 0) { - return true; - } else { - object* px = x.via.array.ptr; - object* const pxend = x.via.array.ptr + x.via.array.size; - object* py = y.via.array.ptr; - do { - if(!(*px == *py)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } + case type::ARRAY: + if(x.via.array.size != y.via.array.size) { + return false; + } else if(x.via.array.size == 0) { + return true; + } else { + object* px = x.via.array.ptr; + object* const pxend = x.via.array.ptr + x.via.array.size; + object* py = y.via.array.ptr; + do { + if(!(*px == *py)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } - case type::MAP: - if(x.via.map.size != y.via.map.size) { - return false; - } else if(x.via.map.size == 0) { - return true; - } else { - object_kv* px = x.via.map.ptr; - object_kv* const pxend = x.via.map.ptr + x.via.map.size; - object_kv* py = y.via.map.ptr; - do { - if(!(px->key == py->key) || !(px->val == py->val)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } + case type::MAP: + if(x.via.map.size != y.via.map.size) { + return false; + } else if(x.via.map.size == 0) { + return true; + } else { + object_kv* px = x.via.map.ptr; + object_kv* const pxend = x.via.map.ptr + x.via.map.size; + object_kv* py = y.via.map.ptr; + do { + if(!(px->key == py->key) || !(px->val == py->val)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } - default: - return false; - } + default: + return false; + } } template inline bool operator==(const object& x, const T& y) try { - return x == object(y); + return x == object(y); } catch (msgpack::type_error&) { - return false; + return false; } inline bool operator!=(const object& x, const object& y) @@ -311,76 +311,76 @@ inline bool operator!=(const T& y, const object& x) inline object::implicit_type object::convert() const { - return implicit_type(*this); + return implicit_type(*this); } template inline void object::convert(T& v) const { - *this >> v; + *this >> v; } template inline void object::convert(T* v) const { - convert(*v); + convert(*v); } template inline T object::as() const { - T v; - convert(v); - return v; + T v; + convert(v); + return v; } inline object::object() { - type = type::NIL; + type = type::NIL; } template inline object::object(const T& v) { - *this << v; + *this << v; } template inline object& object::operator=(const T& v) { - *this = object(v); - return *this; + *this = object(v); + return *this; } template object::object(const T& v, zone* z) { - with_zone oz(z); - oz << v; - type = oz.type; - via = oz.via; + with_zone oz(z); + oz << v; + type = oz.type; + via = oz.via; } inline object::object(msgpack_object o) { - // FIXME beter way? - ::memcpy(this, &o, sizeof(o)); + // FIXME beter way? + ::memcpy(this, &o, sizeof(o)); } inline void operator<< (object& o, msgpack_object v) { - // FIXME beter way? - ::memcpy(&o, &v, sizeof(v)); + // FIXME beter way? + ::memcpy(&o, &v, sizeof(v)); } inline object::operator msgpack_object() const { - // FIXME beter way? - msgpack_object obj; - ::memcpy(&obj, this, sizeof(obj)); - return obj; + // FIXME beter way? + msgpack_object obj; + ::memcpy(&obj, this, sizeof(obj)); + return obj; } @@ -388,151 +388,151 @@ inline object::operator msgpack_object() const template inline void convert(T& v, object const& o) { - o.convert(v); + o.convert(v); } // obsolete template inline void pack(packer& o, const T& v) { - o.pack(v); + o.pack(v); } // obsolete template inline void pack_copy(packer& o, T v) { - pack(o, v); + pack(o, v); } template packer& operator<< (packer& o, const object& v) { - switch(v.type) { - case type::NIL: - o.pack_nil(); - return o; + switch(v.type) { + case type::NIL: + o.pack_nil(); + return o; - case type::BOOLEAN: - if(v.via.boolean) { - o.pack_true(); - } else { - o.pack_false(); - } - return o; + case type::BOOLEAN: + if(v.via.boolean) { + o.pack_true(); + } else { + o.pack_false(); + } + return o; - case type::POSITIVE_INTEGER: - o.pack_uint64(v.via.u64); - return o; + case type::POSITIVE_INTEGER: + o.pack_uint64(v.via.u64); + return o; - case type::NEGATIVE_INTEGER: - o.pack_int64(v.via.i64); - return o; + case type::NEGATIVE_INTEGER: + o.pack_int64(v.via.i64); + return o; - case type::DOUBLE: - o.pack_double(v.via.dec); - return o; + case type::DOUBLE: + o.pack_double(v.via.dec); + return o; - case type::STR: - o.pack_str(v.via.str.size); - o.pack_str_body(v.via.str.ptr, v.via.str.size); - return o; + case type::STR: + o.pack_str(v.via.str.size); + o.pack_str_body(v.via.str.ptr, v.via.str.size); + return o; - case type::BIN: - o.pack_bin(v.via.bin.size); - o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); - return o; + case type::BIN: + o.pack_bin(v.via.bin.size); + o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); + return o; - case type::ARRAY: - o.pack_array(v.via.array.size); - for(object* p(v.via.array.ptr), - * const pend(v.via.array.ptr + v.via.array.size); - p < pend; ++p) { - o << *p; - } - return o; + case type::ARRAY: + o.pack_array(v.via.array.size); + for(object* p(v.via.array.ptr), + * const pend(v.via.array.ptr + v.via.array.size); + p < pend; ++p) { + o << *p; + } + return o; - case type::MAP: - o.pack_map(v.via.map.size); - for(object_kv* p(v.via.map.ptr), - * const pend(v.via.map.ptr + v.via.map.size); - p < pend; ++p) { - o << p->key; - o << p->val; - } - return o; + case type::MAP: + o.pack_map(v.via.map.size); + for(object_kv* p(v.via.map.ptr), + * const pend(v.via.map.ptr + v.via.map.size); + p < pend; ++p) { + o << p->key; + o << p->val; + } + return o; - default: - throw type_error(); - } + default: + throw type_error(); + } } std::ostream& operator<< (std::ostream& s, const object& o) { - switch(o.type) { - case type::NIL: - s << "nil"; - break; + switch(o.type) { + case type::NIL: + s << "nil"; + break; - case type::BOOLEAN: - s << (o.via.boolean ? "true" : "false"); - break; + case type::BOOLEAN: + s << (o.via.boolean ? "true" : "false"); + break; - case type::POSITIVE_INTEGER: - s << o.via.u64; - break; + case type::POSITIVE_INTEGER: + s << o.via.u64; + break; - case type::NEGATIVE_INTEGER: - s << o.via.i64; - break; + case type::NEGATIVE_INTEGER: + s << o.via.i64; + break; - case type::DOUBLE: - s << o.via.dec; - break; + case type::DOUBLE: + s << o.via.dec; + break; - case type::STR: - (s << '"').write(o.via.str.ptr, o.via.str.size) << '"'; - break; + case type::STR: + (s << '"').write(o.via.str.ptr, o.via.str.size) << '"'; + break; - case type::BIN: - (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"'; - break; + case type::BIN: + (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"'; + break; - case type::ARRAY: - s << "["; - if(o.via.array.size != 0) { - object* p(o.via.array.ptr); - s << *p; - ++p; - for(object* const pend(o.via.array.ptr + o.via.array.size); - p < pend; ++p) { - s << ", " << *p; - } - } - s << "]"; - break; + case type::ARRAY: + s << "["; + if(o.via.array.size != 0) { + object* p(o.via.array.ptr); + s << *p; + ++p; + for(object* const pend(o.via.array.ptr + o.via.array.size); + p < pend; ++p) { + s << ", " << *p; + } + } + s << "]"; + break; - case type::MAP: - s << "{"; - if(o.via.map.size != 0) { - object_kv* p(o.via.map.ptr); - s << p->key << "=>" << p->val; - ++p; - for(object_kv* const pend(o.via.map.ptr + o.via.map.size); - p < pend; ++p) { - s << ", " << p->key << "=>" << p->val; - } - } - s << "}"; - break; + case type::MAP: + s << "{"; + if(o.via.map.size != 0) { + object_kv* p(o.via.map.ptr); + s << p->key << "=>" << p->val; + ++p; + for(object_kv* const pend(o.via.map.ptr + o.via.map.size); + p < pend; ++p) { + s << ", " << p->key << "=>" << p->val; + } + } + s << "}"; + break; - default: - // FIXME - s << "#(o.type) << ">"; - } - return s; + default: + // FIXME + s << "#(o.type) << ">"; + } + return s; } } // namespace msgpack diff --git a/include/msgpack/pack.h b/include/msgpack/pack.h index 9735936c..d19c3014 100644 --- a/include/msgpack/pack.h +++ b/include/msgpack/pack.h @@ -43,8 +43,8 @@ extern "C" { typedef int (*msgpack_packer_write)(void* data, const char* buf, size_t len); typedef struct msgpack_packer { - void* data; - msgpack_packer_write callback; + void* data; + msgpack_packer_write callback; } msgpack_packer; static void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback); @@ -107,38 +107,38 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); #define msgpack_pack_inline_func(name) \ - inline int msgpack_pack ## name + inline int msgpack_pack ## name #define msgpack_pack_inline_func_cint(name) \ - inline int msgpack_pack ## name + inline int msgpack_pack ## name #define msgpack_pack_inline_func_fixint(name) \ - inline int msgpack_pack_fix ## name + inline int msgpack_pack_fix ## name #define msgpack_pack_user msgpack_packer* #define msgpack_pack_append_buffer(user, buf, len) \ - return (*(user)->callback)((user)->data, (const char*)buf, len) + return (*(user)->callback)((user)->data, (const char*)buf, len) #include "pack_template.h" inline void msgpack_packer_init(msgpack_packer* pk, void* data, msgpack_packer_write callback) { - pk->data = data; - pk->callback = callback; + pk->data = data; + pk->callback = callback; } inline msgpack_packer* msgpack_packer_new(void* data, msgpack_packer_write callback) { - msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer)); - if(!pk) { return NULL; } - msgpack_packer_init(pk, data, callback); - return pk; + msgpack_packer* pk = (msgpack_packer*)calloc(1, sizeof(msgpack_packer)); + if(!pk) { return NULL; } + msgpack_packer_init(pk, data, callback); + return pk; } inline void msgpack_packer_free(msgpack_packer* pk) { - free(pk); + free(pk); } diff --git a/include/msgpack/pack.hpp b/include/msgpack/pack.hpp index e333d5ab..47958af3 100644 --- a/include/msgpack/pack.hpp +++ b/include/msgpack/pack.hpp @@ -30,136 +30,136 @@ namespace msgpack { template class packer { public: - packer(Stream* s); - packer(Stream& s); + packer(Stream* s); + packer(Stream& s); public: - template - packer& pack(const T& v); + template + packer& pack(const T& v); - packer& pack_uint8(uint8_t d); - packer& pack_uint16(uint16_t d); - packer& pack_uint32(uint32_t d); - packer& pack_uint64(uint64_t d); - packer& pack_int8(int8_t d); - packer& pack_int16(int16_t d); - packer& pack_int32(int32_t d); - packer& pack_int64(int64_t d); + packer& pack_uint8(uint8_t d); + packer& pack_uint16(uint16_t d); + packer& pack_uint32(uint32_t d); + packer& pack_uint64(uint64_t d); + packer& pack_int8(int8_t d); + packer& pack_int16(int16_t d); + packer& pack_int32(int32_t d); + packer& pack_int64(int64_t d); - packer& pack_fix_uint8(uint8_t d); - packer& pack_fix_uint16(uint16_t d); - packer& pack_fix_uint32(uint32_t d); - packer& pack_fix_uint64(uint64_t d); - packer& pack_fix_int8(int8_t d); - packer& pack_fix_int16(int16_t d); - packer& pack_fix_int32(int32_t d); - packer& pack_fix_int64(int64_t d); + packer& pack_fix_uint8(uint8_t d); + packer& pack_fix_uint16(uint16_t d); + packer& pack_fix_uint32(uint32_t d); + packer& pack_fix_uint64(uint64_t d); + packer& pack_fix_int8(int8_t d); + packer& pack_fix_int16(int16_t d); + packer& pack_fix_int32(int32_t d); + packer& pack_fix_int64(int64_t d); - packer& pack_char(char d); - packer& pack_signed_char(signed char d); - packer& pack_short(short d); - packer& pack_int(int d); - packer& pack_long(long d); - packer& pack_long_long(long long d); - packer& pack_unsigned_char(unsigned char d); - packer& pack_unsigned_short(unsigned short d); - packer& pack_unsigned_int(unsigned int d); - packer& pack_unsigned_long(unsigned long d); - packer& pack_unsigned_long_long(unsigned long long d); + packer& pack_char(char d); + packer& pack_signed_char(signed char d); + packer& pack_short(short d); + packer& pack_int(int d); + packer& pack_long(long d); + packer& pack_long_long(long long d); + packer& pack_unsigned_char(unsigned char d); + packer& pack_unsigned_short(unsigned short d); + packer& pack_unsigned_int(unsigned int d); + packer& pack_unsigned_long(unsigned long d); + packer& pack_unsigned_long_long(unsigned long long d); - packer& pack_float(float d); - packer& pack_double(double d); + packer& pack_float(float d); + packer& pack_double(double d); - packer& pack_nil(); - packer& pack_true(); - packer& pack_false(); + packer& pack_nil(); + packer& pack_true(); + packer& pack_false(); - packer& pack_array(size_t n); + packer& pack_array(size_t n); - packer& pack_map(size_t n); + packer& pack_map(size_t n); - packer& pack_str(size_t l); - packer& pack_str_body(const char* b, size_t l); + packer& pack_str(size_t l); + packer& pack_str_body(const char* b, size_t l); - packer& pack_bin(size_t l); - packer& pack_bin_body(const char* b, size_t l); + packer& pack_bin(size_t l); + packer& pack_bin_body(const char* b, size_t l); private: - template - void pack_imp_uint8(T d); - template - void pack_imp_uint16(T d); - template - void pack_imp_uint32(T d); - template - void pack_imp_uint64(T d); - template - void pack_imp_int8(T d); - template - void pack_imp_int16(T d); - template - void pack_imp_int32(T d); - template - void pack_imp_int64(T d); + template + void pack_imp_uint8(T d); + template + void pack_imp_uint16(T d); + template + void pack_imp_uint32(T d); + template + void pack_imp_uint64(T d); + template + void pack_imp_int8(T d); + template + void pack_imp_int16(T d); + template + void pack_imp_int32(T d); + template + void pack_imp_int64(T d); - void append_buffer(const char* buf, size_t len) - { m_stream.write(buf, len); } + void append_buffer(const char* buf, size_t len) + { m_stream.write(buf, len); } private: - Stream& m_stream; + Stream& m_stream; private: - packer(); + packer(); }; template inline void pack(Stream* s, const T& v) { - packer(*s).pack(v); + packer(*s).pack(v); } template inline void pack(Stream& s, const T& v) { - packer(s).pack(v); + packer(s).pack(v); } #if defined(__LITTLE_ENDIAN__) template inline char take8_8(T d) { - return static_cast(reinterpret_cast(&d)[0]); + return static_cast(reinterpret_cast(&d)[0]); } template inline char take8_16(T d) { - return static_cast(reinterpret_cast(&d)[0]); + return static_cast(reinterpret_cast(&d)[0]); } template inline char take8_32(T d) { - return static_cast(reinterpret_cast(&d)[0]); + return static_cast(reinterpret_cast(&d)[0]); } template inline char take8_64(T d) { - return static_cast(reinterpret_cast(&d)[0]); + return static_cast(reinterpret_cast(&d)[0]); } #elif defined(__BIG_ENDIAN__) template inline char take8_8(T d) { - return static_cast(reinterpret_cast(&d)[0]); + return static_cast(reinterpret_cast(&d)[0]); } template inline char take8_16(T d) { - return static_cast(reinterpret_cast(&d)[1]); + return static_cast(reinterpret_cast(&d)[1]); } template inline char take8_32(T d) { - return static_cast(reinterpret_cast(&d)[3]); + return static_cast(reinterpret_cast(&d)[3]); } template inline char take8_64(T d) { - return static_cast(reinterpret_cast(&d)[7]); + return static_cast(reinterpret_cast(&d)[7]); } #endif @@ -207,71 +207,71 @@ inline packer& packer::pack_int64(int64_t d) template inline packer& packer::pack_fix_uint8(uint8_t d) { - char buf[2] = {static_cast(0xcc), take8_8(d)}; - append_buffer(buf, 2); - return *this; + char buf[2] = {static_cast(0xcc), take8_8(d)}; + append_buffer(buf, 2); + return *this; } template inline packer& packer::pack_fix_uint16(uint16_t d) { - char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], d); - append_buffer(buf, 3); - return *this; + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], d); + append_buffer(buf, 3); + return *this; } template inline packer& packer::pack_fix_uint32(uint32_t d) { - char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], d); - append_buffer(buf, 5); - return *this; + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], d); + append_buffer(buf, 5); + return *this; } template inline packer& packer::pack_fix_uint64(uint64_t d) { - char buf[9]; - buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - return *this; + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + return *this; } template inline packer& packer::pack_fix_int8(int8_t d) { - char buf[2] = {static_cast(0xd0), take8_8(d)}; - append_buffer(buf, 2); - return *this; + char buf[2] = {static_cast(0xd0), take8_8(d)}; + append_buffer(buf, 2); + return *this; } template inline packer& packer::pack_fix_int16(int16_t d) { - char buf[3]; - buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], d); - append_buffer(buf, 3); - return *this; + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], d); + append_buffer(buf, 3); + return *this; } template inline packer& packer::pack_fix_int32(int32_t d) { - char buf[5]; - buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], d); - append_buffer(buf, 5); - return *this; + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], d); + append_buffer(buf, 5); + return *this; } template inline packer& packer::pack_fix_int64(int64_t d) { - char buf[9]; - buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - return *this; + char buf[9]; + buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + return *this; } @@ -288,32 +288,32 @@ inline packer& packer::pack_short(short d) { #if defined(SIZEOF_SHORT) #if SIZEOF_SHORT == 2 - pack_imp_int16(d); + pack_imp_int16(d); #elif SIZEOF_SHORT == 4 - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #elif defined(SHRT_MAX) #if SHRT_MAX == 0x7fff - pack_imp_int16(d); + pack_imp_int16(d); #elif SHRT_MAX == 0x7fffffff - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #else - if(sizeof(short) == 2) { - pack_imp_int16(d); - } else if(sizeof(short) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } + if(sizeof(short) == 2) { + pack_imp_int16(d); + } else if(sizeof(short) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } #endif - return *this; + return *this; } template @@ -321,32 +321,32 @@ inline packer& packer::pack_int(int d) { #if defined(SIZEOF_INT) #if SIZEOF_INT == 2 - pack_imp_int16(d); + pack_imp_int16(d); #elif SIZEOF_INT == 4 - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #elif defined(INT_MAX) #if INT_MAX == 0x7fff - pack_imp_int16(d); + pack_imp_int16(d); #elif INT_MAX == 0x7fffffff - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #else - if(sizeof(int) == 2) { - pack_imp_int16(d); - } else if(sizeof(int) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } + if(sizeof(int) == 2) { + pack_imp_int16(d); + } else if(sizeof(int) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } #endif - return *this; + return *this; } template @@ -354,32 +354,32 @@ inline packer& packer::pack_long(long d) { #if defined(SIZEOF_LONG) #if SIZEOF_LONG == 2 - pack_imp_int16(d); + pack_imp_int16(d); #elif SIZEOF_LONG == 4 - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #elif defined(LONG_MAX) #if LONG_MAX == 0x7fffL - pack_imp_int16(d); + pack_imp_int16(d); #elif LONG_MAX == 0x7fffffffL - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #else - if(sizeof(long) == 2) { - pack_imp_int16(d); - } else if(sizeof(long) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } + if(sizeof(long) == 2) { + pack_imp_int16(d); + } else if(sizeof(long) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } #endif - return *this; + return *this; } template @@ -387,32 +387,32 @@ inline packer& packer::pack_long_long(long long d) { #if defined(SIZEOF_LONG_LONG) #if SIZEOF_LONG_LONG == 2 - pack_imp_int16(d); + pack_imp_int16(d); #elif SIZEOF_LONG_LONG == 4 - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #elif defined(LLONG_MAX) #if LLONG_MAX == 0x7fffL - pack_imp_int16(d); + pack_imp_int16(d); #elif LLONG_MAX == 0x7fffffffL - pack_imp_int32(d); + pack_imp_int32(d); #else - pack_imp_int64(d); + pack_imp_int64(d); #endif #else - if(sizeof(long long) == 2) { - pack_imp_int16(d); - } else if(sizeof(long long) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } + if(sizeof(long long) == 2) { + pack_imp_int16(d); + } else if(sizeof(long long) == 4) { + pack_imp_int32(d); + } else { + pack_imp_int64(d); + } #endif - return *this; + return *this; } @@ -425,32 +425,32 @@ inline packer& packer::pack_unsigned_short(unsigned short d) { #if defined(SIZEOF_SHORT) #if SIZEOF_SHORT == 2 - pack_imp_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_SHORT == 4 - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #elif defined(USHRT_MAX) #if USHRT_MAX == 0xffffU - pack_imp_uint16(d); + pack_imp_uint16(d); #elif USHRT_MAX == 0xffffffffU - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #else - if(sizeof(unsigned short) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned short) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } + if(sizeof(unsigned short) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned short) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } #endif - return *this; + return *this; } template @@ -458,32 +458,32 @@ inline packer& packer::pack_unsigned_int(unsigned int d) { #if defined(SIZEOF_INT) #if SIZEOF_INT == 2 - pack_imp_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_INT == 4 - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #elif defined(UINT_MAX) #if UINT_MAX == 0xffffU - pack_imp_uint16(d); + pack_imp_uint16(d); #elif UINT_MAX == 0xffffffffU - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #else - if(sizeof(unsigned int) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned int) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } + if(sizeof(unsigned int) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned int) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } #endif - return *this; + return *this; } template @@ -491,32 +491,32 @@ inline packer& packer::pack_unsigned_long(unsigned long d) { #if defined(SIZEOF_LONG) #if SIZEOF_LONG == 2 - pack_imp_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_LONG == 4 - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #elif defined(ULONG_MAX) #if ULONG_MAX == 0xffffUL - pack_imp_uint16(d); + pack_imp_uint16(d); #elif ULONG_MAX == 0xffffffffUL - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #else - if(sizeof(unsigned long) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned long) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } + if(sizeof(unsigned long) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned long) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } #endif - return *this; + return *this; } template @@ -524,429 +524,429 @@ inline packer& packer::pack_unsigned_long_long(unsigned long lon { #if defined(SIZEOF_LONG_LONG) #if SIZEOF_LONG_LONG == 2 - pack_imp_uint16(d); + pack_imp_uint16(d); #elif SIZEOF_LONG_LONG == 4 - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #elif defined(ULLONG_MAX) #if ULLONG_MAX == 0xffffUL - pack_imp_uint16(d); + pack_imp_uint16(d); #elif ULLONG_MAX == 0xffffffffUL - pack_imp_uint32(d); + pack_imp_uint32(d); #else - pack_imp_uint64(d); + pack_imp_uint64(d); #endif #else - if(sizeof(unsigned long long) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned long long) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } + if(sizeof(unsigned long long) == 2) { + pack_imp_uint16(d); + } else if(sizeof(unsigned long long) == 4) { + pack_imp_uint32(d); + } else { + pack_imp_uint64(d); + } #endif - return *this; + return *this; } template inline packer& packer::pack_float(float d) { - union { float f; uint32_t i; } mem; - mem.f = d; - char buf[5]; - buf[0] = static_cast(0xca); _msgpack_store32(&buf[1], mem.i); - append_buffer(buf, 5); - return *this; + union { float f; uint32_t i; } mem; + mem.f = d; + char buf[5]; + buf[0] = static_cast(0xca); _msgpack_store32(&buf[1], mem.i); + append_buffer(buf, 5); + return *this; } template inline packer& packer::pack_double(double d) { - union { double f; uint64_t i; } mem; - mem.f = d; - char buf[9]; - buf[0] = static_cast(0xcb); + union { double f; uint64_t i; } mem; + mem.f = d; + char buf[9]; + buf[0] = static_cast(0xcb); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - _msgpack_store64(&buf[1], mem.i); - append_buffer(buf, 9); - return *this; + _msgpack_store64(&buf[1], mem.i); + append_buffer(buf, 9); + return *this; } template inline packer& packer::pack_nil() { - const char d = static_cast(0xc0); - append_buffer(&d, 1); - return *this; + const char d = static_cast(0xc0); + append_buffer(&d, 1); + return *this; } template inline packer& packer::pack_true() { - const char d = static_cast(0xc3); - append_buffer(&d, 1); - return *this; + const char d = static_cast(0xc3); + append_buffer(&d, 1); + return *this; } template inline packer& packer::pack_false() { - const char d = static_cast(0xc2); - append_buffer(&d, 1); - return *this; + const char d = static_cast(0xc2); + append_buffer(&d, 1); + return *this; } template inline packer& packer::pack_array(size_t n) { - if(n < 16) { - char d = static_cast(0x90 | n); - append_buffer(&d, 1); - } else if(n < 65536) { - char buf[3]; - buf[0] = static_cast(0xdc); _msgpack_store16(&buf[1], static_cast(n)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xdd); _msgpack_store32(&buf[1], static_cast(n)); - append_buffer(buf, 5); - } - return *this; + if(n < 16) { + char d = static_cast(0x90 | n); + append_buffer(&d, 1); + } else if(n < 65536) { + char buf[3]; + buf[0] = static_cast(0xdc); _msgpack_store16(&buf[1], static_cast(n)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xdd); _msgpack_store32(&buf[1], static_cast(n)); + append_buffer(buf, 5); + } + return *this; } template inline packer& packer::pack_map(size_t n) { - if(n < 16) { - unsigned char d = 0x80 | n; - char buf = take8_8(d); - append_buffer(&buf, 1); - } else if(n < 65536) { - char buf[3]; - buf[0] = static_cast(0xde); _msgpack_store16(&buf[1], static_cast(n)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xdf); _msgpack_store32(&buf[1], static_cast(n)); - append_buffer(buf, 5); - } - return *this; + if(n < 16) { + unsigned char d = 0x80 | n; + char buf = take8_8(d); + append_buffer(&buf, 1); + } else if(n < 65536) { + char buf[3]; + buf[0] = static_cast(0xde); _msgpack_store16(&buf[1], static_cast(n)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xdf); _msgpack_store32(&buf[1], static_cast(n)); + append_buffer(buf, 5); + } + return *this; } template inline packer& packer::pack_str(size_t l) { - if(l < 32) { - unsigned char d = 0xa0 | static_cast(l); - char buf = take8_8(d); - append_buffer(&buf, 1); - } else if(l < 256) { - char buf[2]; - buf[0] = static_cast(0xd9); buf[1] = static_cast(l); - append_buffer(buf, 2); - } else if(l < 65536) { - char buf[3]; - buf[0] = static_cast(0xda); _msgpack_store16(&buf[1], static_cast(l)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xdb); _msgpack_store32(&buf[1], static_cast(l)); - append_buffer(buf, 5); - } - return *this; + if(l < 32) { + unsigned char d = 0xa0 | static_cast(l); + char buf = take8_8(d); + append_buffer(&buf, 1); + } else if(l < 256) { + char buf[2]; + buf[0] = static_cast(0xd9); buf[1] = static_cast(l); + append_buffer(buf, 2); + } else if(l < 65536) { + char buf[3]; + buf[0] = static_cast(0xda); _msgpack_store16(&buf[1], static_cast(l)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xdb); _msgpack_store32(&buf[1], static_cast(l)); + append_buffer(buf, 5); + } + return *this; } template inline packer& packer::pack_str_body(const char* b, size_t l) { - append_buffer(b, l); - return *this; + append_buffer(b, l); + return *this; } template inline packer& packer::pack_bin(size_t l) { - if(l < 256) { - char buf[2]; - buf[0] = static_cast(0xc4); buf[1] = static_cast(l); - append_buffer(buf, 2); - } else if(l < 65536) { - char buf[3]; - buf[0] = static_cast(0xc5); _msgpack_store16(&buf[1], static_cast(l)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xc6); _msgpack_store32(&buf[1], static_cast(l)); - append_buffer(buf, 5); - } - return *this; + if(l < 256) { + char buf[2]; + buf[0] = static_cast(0xc4); buf[1] = static_cast(l); + append_buffer(buf, 2); + } else if(l < 65536) { + char buf[3]; + buf[0] = static_cast(0xc5); _msgpack_store16(&buf[1], static_cast(l)); + append_buffer(buf, 3); + } else { + char buf[5]; + buf[0] = static_cast(0xc6); _msgpack_store32(&buf[1], static_cast(l)); + append_buffer(buf, 5); + } + return *this; } template inline packer& packer::pack_bin_body(const char* b, size_t l) { - append_buffer(b, l); - return *this; + append_buffer(b, l); + return *this; } template template inline void packer::pack_imp_uint8(T d) { - if(d < (1<<7)) { - /* fixnum */ - char buf = take8_8(d); - append_buffer(&buf, 1); - } else { - /* unsigned 8 */ - char buf[2] = {static_cast(0xcc), take8_8(d)}; - append_buffer(buf, 2); - } + if(d < (1<<7)) { + /* fixnum */ + char buf = take8_8(d); + append_buffer(&buf, 1); + } else { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_8(d)}; + append_buffer(buf, 2); + } } template template inline void packer::pack_imp_uint16(T d) { - if(d < (1<<7)) { - /* fixnum */ - char buf = take8_16(d); - append_buffer(&buf, 1); - } else if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = {static_cast(0xcc), take8_16(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } + if(d < (1<<7)) { + /* fixnum */ + char buf = take8_16(d); + append_buffer(&buf, 1); + } else if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } } template template inline void packer::pack_imp_uint32(T d) { - if(d < (1<<8)) { - if(d < (1<<7)) { - /* fixnum */ - char buf = take8_32(d); - append_buffer(&buf, 1); - } else { - /* unsigned 8 */ - char buf[2] = {static_cast(0xcc), take8_32(d)}; - append_buffer(buf, 2); - } - } else { - if(d < (1<<16)) { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } - } + if(d < (1<<8)) { + if(d < (1<<7)) { + /* fixnum */ + char buf = take8_32(d); + append_buffer(&buf, 1); + } else { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_32(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1<<16)) { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } + } } template template inline void packer::pack_imp_uint64(T d) { - if(d < (1ULL<<8)) { - if(d < (1ULL<<7)) { - /* fixnum */ - char buf = take8_64(d); - append_buffer(&buf, 1); - } else { - /* unsigned 8 */ - char buf[2] = {static_cast(0xcc), take8_64(d)}; - append_buffer(buf, 2); - } - } else { - if(d < (1ULL<<16)) { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else if(d < (1ULL<<32)) { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } else { - /* unsigned 64 */ - char buf[9]; - buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } - } + if(d < (1ULL<<8)) { + if(d < (1ULL<<7)) { + /* fixnum */ + char buf = take8_64(d); + append_buffer(&buf, 1); + } else { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_64(d)}; + append_buffer(buf, 2); + } + } else { + if(d < (1ULL<<16)) { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else if(d < (1ULL<<32)) { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } } template template inline void packer::pack_imp_int8(T d) { - if(d < -(1<<5)) { - /* signed 8 */ - char buf[2] = {static_cast(0xd0), take8_8(d)}; - append_buffer(buf, 2); - } else { - /* fixnum */ - char buf = take8_8(d); - append_buffer(&buf, 1); - } + if(d < -(1<<5)) { + /* signed 8 */ + char buf[2] = {static_cast(0xd0), take8_8(d)}; + append_buffer(buf, 2); + } else { + /* fixnum */ + char buf = take8_8(d); + append_buffer(&buf, 1); + } } template template inline void packer::pack_imp_int16(T d) { - if(d < -(1<<5)) { - if(d < -(1<<7)) { - /* signed 16 */ - char buf[3]; - buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* signed 8 */ - char buf[2] = {static_cast(0xd0), take8_16(d)}; - append_buffer(buf, 2); - } - } else if(d < (1<<7)) { - /* fixnum */ - char buf = take8_16(d); - append_buffer(&buf, 1); - } else { - if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = {static_cast(0xcc), take8_16(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } - } + if(d < -(1<<5)) { + if(d < -(1<<7)) { + /* signed 16 */ + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* signed 8 */ + char buf[2] = {static_cast(0xd0), take8_16(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + char buf = take8_16(d); + append_buffer(&buf, 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_16(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } + } } template template inline void packer::pack_imp_int32(T d) { - if(d < -(1<<5)) { - if(d < -(1<<15)) { - /* signed 32 */ - char buf[5]; - buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } else if(d < -(1<<7)) { - /* signed 16 */ - char buf[3]; - buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* signed 8 */ - char buf[2] = { static_cast(0xd0), take8_32(d)}; - append_buffer(buf, 2); - } - } else if(d < (1<<7)) { - /* fixnum */ - char buf = take8_32(d); - append_buffer(&buf, 1); - } else { - if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = { static_cast(0xcc), take8_32(d)}; - append_buffer(buf, 2); - } else if(d < (1<<16)) { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } - } + if(d < -(1<<5)) { + if(d < -(1<<15)) { + /* signed 32 */ + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } else if(d < -(1<<7)) { + /* signed 16 */ + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* signed 8 */ + char buf[2] = { static_cast(0xd0), take8_32(d)}; + append_buffer(buf, 2); + } + } else if(d < (1<<7)) { + /* fixnum */ + char buf = take8_32(d); + append_buffer(&buf, 1); + } else { + if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = { static_cast(0xcc), take8_32(d)}; + append_buffer(buf, 2); + } else if(d < (1<<16)) { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } + } } template template inline void packer::pack_imp_int64(T d) { - if(d < -(1LL<<5)) { - if(d < -(1LL<<15)) { - if(d < -(1LL<<31)) { - /* signed 64 */ - char buf[9]; - buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } else { - /* signed 32 */ - char buf[5]; - buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } - } else { - if(d < -(1<<7)) { - /* signed 16 */ - char buf[3]; - buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* signed 8 */ - char buf[2] = {static_cast(0xd0), take8_64(d)}; - append_buffer(buf, 2); - } - } - } else if(d < (1<<7)) { - /* fixnum */ - char buf = take8_64(d); - append_buffer(&buf, 1); - } else { - if(d < (1LL<<16)) { - if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = {static_cast(0xcc), take8_64(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } - } else { - if(d < (1LL<<32)) { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } else { - /* unsigned 64 */ - char buf[9]; - buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } - } - } + if(d < -(1LL<<5)) { + if(d < -(1LL<<15)) { + if(d < -(1LL<<31)) { + /* signed 64 */ + char buf[9]; + buf[0] = static_cast(0xd3); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } else { + /* signed 32 */ + char buf[5]; + buf[0] = static_cast(0xd2); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } + } else { + if(d < -(1<<7)) { + /* signed 16 */ + char buf[3]; + buf[0] = static_cast(0xd1); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } else { + /* signed 8 */ + char buf[2] = {static_cast(0xd0), take8_64(d)}; + append_buffer(buf, 2); + } + } + } else if(d < (1<<7)) { + /* fixnum */ + char buf = take8_64(d); + append_buffer(&buf, 1); + } else { + if(d < (1LL<<16)) { + if(d < (1<<8)) { + /* unsigned 8 */ + char buf[2] = {static_cast(0xcc), take8_64(d)}; + append_buffer(buf, 2); + } else { + /* unsigned 16 */ + char buf[3]; + buf[0] = static_cast(0xcd); _msgpack_store16(&buf[1], static_cast(d)); + append_buffer(buf, 3); + } + } else { + if(d < (1LL<<32)) { + /* unsigned 32 */ + char buf[5]; + buf[0] = static_cast(0xce); _msgpack_store32(&buf[1], static_cast(d)); + append_buffer(buf, 5); + } else { + /* unsigned 64 */ + char buf[9]; + buf[0] = static_cast(0xcf); _msgpack_store64(&buf[1], d); + append_buffer(buf, 9); + } + } + } } } // namespace msgpack diff --git a/include/msgpack/pack_template.h b/include/msgpack/pack_template.h index 2576a380..f86f6e8d 100644 --- a/include/msgpack/pack_template.h +++ b/include/msgpack/pack_template.h @@ -47,228 +47,228 @@ #define msgpack_pack_real_uint8(x, d) \ do { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ + if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ + } else { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ } while(0) #define msgpack_pack_real_uint16(x, d) \ do { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ - } else if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ + if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ + } else if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } \ } while(0) #define msgpack_pack_real_uint32(x, d) \ do { \ - if(d < (1<<8)) { \ - if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else { \ - if(d < (1<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } \ + if(d < (1<<8)) { \ + if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ + } else { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else { \ + if(d < (1<<16)) { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } \ + } \ } while(0) #define msgpack_pack_real_uint64(x, d) \ do { \ - if(d < (1ULL<<8)) { \ - if(d < (1ULL<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ - } else { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else { \ - if(d < (1ULL<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else if(d < (1ULL<<32)) { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else { \ - /* unsigned 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } \ - } \ + if(d < (1ULL<<8)) { \ + if(d < (1ULL<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ + } else { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else { \ + if(d < (1ULL<<16)) { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else if(d < (1ULL<<32)) { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } else { \ + /* unsigned 64 */ \ + unsigned char buf[9]; \ + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ + msgpack_pack_append_buffer(x, buf, 9); \ + } \ + } \ } while(0) #define msgpack_pack_real_int8(x, d) \ do { \ - if(d < -(1<<5)) { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ - } \ + if(d < -(1<<5)) { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ + } \ } while(0) #define msgpack_pack_real_int16(x, d) \ do { \ - if(d < -(1<<5)) { \ - if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ - } else { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ - } \ + if(d < -(1<<5)) { \ + if(d < -(1<<7)) { \ + /* signed 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ + } else { \ + if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } \ + } \ } while(0) #define msgpack_pack_real_int32(x, d) \ do { \ - if(d < -(1<<5)) { \ - if(d < -(1<<15)) { \ - /* signed 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ - } else { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else if(d < (1<<16)) { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } \ + if(d < -(1<<5)) { \ + if(d < -(1<<15)) { \ + /* signed 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } else if(d < -(1<<7)) { \ + /* signed 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } else if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ + } else { \ + if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else if(d < (1<<16)) { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } \ + } \ } while(0) #define msgpack_pack_real_int64(x, d) \ do { \ - if(d < -(1LL<<5)) { \ - if(d < -(1LL<<15)) { \ - if(d < -(1LL<<31)) { \ - /* signed 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } else { \ - /* signed 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } \ - } else { \ - if(d < -(1<<7)) { \ - /* signed 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } else { \ - /* signed 8 */ \ - unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } \ - } \ - } else if(d < (1<<7)) { \ - /* fixnum */ \ - msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ - } else { \ - if(d < (1LL<<16)) { \ - if(d < (1<<8)) { \ - /* unsigned 8 */ \ - unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ - msgpack_pack_append_buffer(x, buf, 2); \ - } else { \ - /* unsigned 16 */ \ - unsigned char buf[3]; \ - buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ - msgpack_pack_append_buffer(x, buf, 3); \ - } \ - } else { \ - if(d < (1LL<<32)) { \ - /* unsigned 32 */ \ - unsigned char buf[5]; \ - buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ - msgpack_pack_append_buffer(x, buf, 5); \ - } else { \ - /* unsigned 64 */ \ - unsigned char buf[9]; \ - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ - msgpack_pack_append_buffer(x, buf, 9); \ - } \ - } \ - } \ + if(d < -(1LL<<5)) { \ + if(d < -(1LL<<15)) { \ + if(d < -(1LL<<31)) { \ + /* signed 64 */ \ + unsigned char buf[9]; \ + buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \ + msgpack_pack_append_buffer(x, buf, 9); \ + } else { \ + /* signed 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } \ + } else { \ + if(d < -(1<<7)) { \ + /* signed 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } else { \ + /* signed 8 */ \ + unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } \ + } \ + } else if(d < (1<<7)) { \ + /* fixnum */ \ + msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ + } else { \ + if(d < (1LL<<16)) { \ + if(d < (1<<8)) { \ + /* unsigned 8 */ \ + unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ + msgpack_pack_append_buffer(x, buf, 2); \ + } else { \ + /* unsigned 16 */ \ + unsigned char buf[3]; \ + buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ + msgpack_pack_append_buffer(x, buf, 3); \ + } \ + } else { \ + if(d < (1LL<<32)) { \ + /* unsigned 32 */ \ + unsigned char buf[5]; \ + buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ + msgpack_pack_append_buffer(x, buf, 5); \ + } else { \ + /* unsigned 64 */ \ + unsigned char buf[9]; \ + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ + msgpack_pack_append_buffer(x, buf, 9); \ + } \ + } \ + } \ } while(0) @@ -276,56 +276,56 @@ do { \ msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d) { - unsigned char buf[2] = {0xcc, TAKE8_8(d)}; - msgpack_pack_append_buffer(x, buf, 2); + unsigned char buf[2] = {0xcc, TAKE8_8(d)}; + msgpack_pack_append_buffer(x, buf, 2); } msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d) { - unsigned char buf[3]; - buf[0] = 0xcd; _msgpack_store16(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 3); + unsigned char buf[3]; + buf[0] = 0xcd; _msgpack_store16(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 3); } msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d) { - unsigned char buf[5]; - buf[0] = 0xce; _msgpack_store32(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 5); + unsigned char buf[5]; + buf[0] = 0xce; _msgpack_store32(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 5); } msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d) { - unsigned char buf[9]; - buf[0] = 0xcf; _msgpack_store64(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 9); + unsigned char buf[9]; + buf[0] = 0xcf; _msgpack_store64(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 9); } msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d) { - unsigned char buf[2] = {0xd0, TAKE8_8(d)}; - msgpack_pack_append_buffer(x, buf, 2); + unsigned char buf[2] = {0xd0, TAKE8_8(d)}; + msgpack_pack_append_buffer(x, buf, 2); } msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d) { - unsigned char buf[3]; - buf[0] = 0xd1; _msgpack_store16(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 3); + unsigned char buf[3]; + buf[0] = 0xd1; _msgpack_store16(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 3); } msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d) { - unsigned char buf[5]; - buf[0] = 0xd2; _msgpack_store32(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 5); + unsigned char buf[5]; + buf[0] = 0xd2; _msgpack_store32(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 5); } msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d) { - unsigned char buf[9]; - buf[0] = 0xd3; _msgpack_store64(&buf[1], d); - msgpack_pack_append_buffer(x, buf, 9); + unsigned char buf[9]; + buf[0] = 0xd3; _msgpack_store64(&buf[1], d); + msgpack_pack_append_buffer(x, buf, 9); } #undef msgpack_pack_inline_func_fixint @@ -334,51 +334,51 @@ msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d) msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d) { - msgpack_pack_real_uint8(x, d); + msgpack_pack_real_uint8(x, d); } msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d) { - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); } msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d) { - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); } msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d) { - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); } msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d) { - msgpack_pack_real_int8(x, d); + msgpack_pack_real_int8(x, d); } msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d) { - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); } msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d) { - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); } msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d) { - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); } msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d) { #if defined(CHAR_MIN) #if CHAR_MIN < 0 - msgpack_pack_real_int8(x, d); + msgpack_pack_real_int8(x, d); #else - msgpack_pack_real_uint8(x, d); + msgpack_pack_real_uint8(x, d); #endif #else #error CHAR_MIN is not defined @@ -387,12 +387,12 @@ msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d) msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d) { - msgpack_pack_real_int8(x, d); + msgpack_pack_real_int8(x, d); } msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d) { - msgpack_pack_real_uint8(x, d); + msgpack_pack_real_uint8(x, d); } #ifdef msgpack_pack_inline_func_cint @@ -401,29 +401,29 @@ msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d) { #if defined(SIZEOF_SHORT) #if SIZEOF_SHORT == 2 - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif SIZEOF_SHORT == 4 - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #elif defined(SHRT_MAX) #if SHRT_MAX == 0x7fff - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif SHRT_MAX == 0x7fffffff - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #else if(sizeof(short) == 2) { - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); } else if(sizeof(short) == 4) { - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); } else { - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); } #endif } @@ -432,29 +432,29 @@ msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d) { #if defined(SIZEOF_INT) #if SIZEOF_INT == 2 - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif SIZEOF_INT == 4 - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #elif defined(INT_MAX) #if INT_MAX == 0x7fff - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif INT_MAX == 0x7fffffff - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #else if(sizeof(int) == 2) { - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); } else if(sizeof(int) == 4) { - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); } else { - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); } #endif } @@ -463,29 +463,29 @@ msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d) { #if defined(SIZEOF_LONG) #if SIZEOF_LONG == 2 - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif SIZEOF_LONG == 4 - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #elif defined(LONG_MAX) #if LONG_MAX == 0x7fffL - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif LONG_MAX == 0x7fffffffL - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #else if(sizeof(long) == 2) { - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); } else if(sizeof(long) == 4) { - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); } else { - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); } #endif } @@ -494,29 +494,29 @@ msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d) { #if defined(SIZEOF_LONG_LONG) #if SIZEOF_LONG_LONG == 2 - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif SIZEOF_LONG_LONG == 4 - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #elif defined(LLONG_MAX) #if LLONG_MAX == 0x7fffL - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); #elif LLONG_MAX == 0x7fffffffL - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); #else - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); #endif #else if(sizeof(long long) == 2) { - msgpack_pack_real_int16(x, d); + msgpack_pack_real_int16(x, d); } else if(sizeof(long long) == 4) { - msgpack_pack_real_int32(x, d); + msgpack_pack_real_int32(x, d); } else { - msgpack_pack_real_int64(x, d); + msgpack_pack_real_int64(x, d); } #endif } @@ -525,29 +525,29 @@ msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned sho { #if defined(SIZEOF_SHORT) #if SIZEOF_SHORT == 2 - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif SIZEOF_SHORT == 4 - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #elif defined(USHRT_MAX) #if USHRT_MAX == 0xffffU - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif USHRT_MAX == 0xffffffffU - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #else if(sizeof(unsigned short) == 2) { - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); } else if(sizeof(unsigned short) == 4) { - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); } else { - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); } #endif } @@ -556,29 +556,29 @@ msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d { #if defined(SIZEOF_INT) #if SIZEOF_INT == 2 - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif SIZEOF_INT == 4 - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #elif defined(UINT_MAX) #if UINT_MAX == 0xffffU - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif UINT_MAX == 0xffffffffU - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #else if(sizeof(unsigned int) == 2) { - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); } else if(sizeof(unsigned int) == 4) { - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); } else { - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); } #endif } @@ -587,29 +587,29 @@ msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long { #if defined(SIZEOF_LONG) #if SIZEOF_LONG == 2 - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif SIZEOF_LONG == 4 - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #elif defined(ULONG_MAX) #if ULONG_MAX == 0xffffUL - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif ULONG_MAX == 0xffffffffUL - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #else if(sizeof(unsigned long) == 2) { - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); } else if(sizeof(unsigned long) == 4) { - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); } else { - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); } #endif } @@ -618,29 +618,29 @@ msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned { #if defined(SIZEOF_LONG_LONG) #if SIZEOF_LONG_LONG == 2 - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif SIZEOF_LONG_LONG == 4 - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #elif defined(ULLONG_MAX) #if ULLONG_MAX == 0xffffUL - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); #elif ULLONG_MAX == 0xffffffffUL - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); #else - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); #endif #else if(sizeof(unsigned long long) == 2) { - msgpack_pack_real_uint16(x, d); + msgpack_pack_real_uint16(x, d); } else if(sizeof(unsigned long long) == 4) { - msgpack_pack_real_uint32(x, d); + msgpack_pack_real_uint32(x, d); } else { - msgpack_pack_real_uint64(x, d); + msgpack_pack_real_uint64(x, d); } #endif } @@ -656,25 +656,25 @@ if(sizeof(unsigned long long) == 2) { msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d) { - unsigned char buf[5]; - union { float f; uint32_t i; } mem; - mem.f = d; - buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); - msgpack_pack_append_buffer(x, buf, 5); + unsigned char buf[5]; + union { float f; uint32_t i; } mem; + mem.f = d; + buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); + msgpack_pack_append_buffer(x, buf, 5); } msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d) { - unsigned char buf[9]; - union { double f; uint64_t i; } mem; - mem.f = d; - buf[0] = 0xcb; + unsigned char buf[9]; + union { double f; uint64_t i; } mem; + mem.f = d; + buf[0] = 0xcb; #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif _msgpack_store64(&buf[1], mem.i); - msgpack_pack_append_buffer(x, buf, 9); + msgpack_pack_append_buffer(x, buf, 9); } @@ -684,8 +684,8 @@ msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d) msgpack_pack_inline_func(_nil)(msgpack_pack_user x) { - static const unsigned char d = 0xc0; - msgpack_pack_append_buffer(x, &d, 1); + static const unsigned char d = 0xc0; + msgpack_pack_append_buffer(x, &d, 1); } @@ -695,14 +695,14 @@ msgpack_pack_inline_func(_nil)(msgpack_pack_user x) msgpack_pack_inline_func(_true)(msgpack_pack_user x) { - static const unsigned char d = 0xc3; - msgpack_pack_append_buffer(x, &d, 1); + static const unsigned char d = 0xc3; + msgpack_pack_append_buffer(x, &d, 1); } msgpack_pack_inline_func(_false)(msgpack_pack_user x) { - static const unsigned char d = 0xc2; - msgpack_pack_append_buffer(x, &d, 1); + static const unsigned char d = 0xc2; + msgpack_pack_append_buffer(x, &d, 1); } @@ -712,18 +712,18 @@ msgpack_pack_inline_func(_false)(msgpack_pack_user x) msgpack_pack_inline_func(_array)(msgpack_pack_user x, size_t n) { - if(n < 16) { - unsigned char d = 0x90 | (uint8_t)n; - msgpack_pack_append_buffer(x, &d, 1); - } else if(n < 65536) { - unsigned char buf[3]; - buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); - msgpack_pack_append_buffer(x, buf, 5); - } + if(n < 16) { + unsigned char d = 0x90 | (uint8_t)n; + msgpack_pack_append_buffer(x, &d, 1); + } else if(n < 65536) { + unsigned char buf[3]; + buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); + msgpack_pack_append_buffer(x, buf, 5); + } } @@ -733,18 +733,18 @@ msgpack_pack_inline_func(_array)(msgpack_pack_user x, size_t n) msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n) { - if(n < 16) { - unsigned char d = 0x80 | (uint8_t)n; - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); - } else if(n < 65536) { - unsigned char buf[3]; - buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); - msgpack_pack_append_buffer(x, buf, 5); - } + if(n < 16) { + unsigned char d = 0x80 | (uint8_t)n; + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); + } else if(n < 65536) { + unsigned char buf[3]; + buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); + msgpack_pack_append_buffer(x, buf, 5); + } } @@ -754,27 +754,27 @@ msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n) msgpack_pack_inline_func(_str)(msgpack_pack_user x, size_t l) { - if(l < 32) { - unsigned char d = 0xa0 | (uint8_t)l; - msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); - } else if(l < 256) { - unsigned char buf[2]; - buf[0] = 0xd9; buf[1] = (uint8_t)l; - msgpack_pack_append_buffer(x, buf, 2); - } else if(l < 65536) { - unsigned char buf[3]; - buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); - msgpack_pack_append_buffer(x, buf, 5); - } + if(l < 32) { + unsigned char d = 0xa0 | (uint8_t)l; + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); + } else if(l < 256) { + unsigned char buf[2]; + buf[0] = 0xd9; buf[1] = (uint8_t)l; + msgpack_pack_append_buffer(x, buf, 2); + } else if(l < 65536) { + unsigned char buf[3]; + buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); + msgpack_pack_append_buffer(x, buf, 5); + } } msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l) { - msgpack_pack_append_buffer(x, (const unsigned char*)b, l); + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); } /* @@ -783,24 +783,24 @@ msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l msgpack_pack_inline_func(_bin)(msgpack_pack_user x, size_t l) { - if(l < 256) { - unsigned char buf[2]; - buf[0] = 0xc4; buf[1] = (uint8_t)l; - msgpack_pack_append_buffer(x, buf, 2); - } else if(l < 65536) { - unsigned char buf[3]; - buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l); - msgpack_pack_append_buffer(x, buf, 3); - } else { - unsigned char buf[5]; - buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l); - msgpack_pack_append_buffer(x, buf, 5); - } + if(l < 256) { + unsigned char buf[2]; + buf[0] = 0xc4; buf[1] = (uint8_t)l; + msgpack_pack_append_buffer(x, buf, 2); + } else if(l < 65536) { + unsigned char buf[3]; + buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l); + msgpack_pack_append_buffer(x, buf, 5); + } } msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l) { - msgpack_pack_append_buffer(x, (const unsigned char*)b, l); + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); } #undef msgpack_pack_inline_func diff --git a/include/msgpack/sbuffer.h b/include/msgpack/sbuffer.h index 5a18cf38..edfb246f 100644 --- a/include/msgpack/sbuffer.h +++ b/include/msgpack/sbuffer.h @@ -33,31 +33,31 @@ extern "C" { */ typedef struct msgpack_sbuffer { - size_t size; - char* data; - size_t alloc; + size_t size; + char* data; + size_t alloc; } msgpack_sbuffer; static inline void msgpack_sbuffer_init(msgpack_sbuffer* sbuf) { - memset(sbuf, 0, sizeof(msgpack_sbuffer)); + memset(sbuf, 0, sizeof(msgpack_sbuffer)); } static inline void msgpack_sbuffer_destroy(msgpack_sbuffer* sbuf) { - free(sbuf->data); + free(sbuf->data); } static inline msgpack_sbuffer* msgpack_sbuffer_new(void) { - return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer)); + return (msgpack_sbuffer*)calloc(1, sizeof(msgpack_sbuffer)); } static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf) { - if(sbuf == NULL) { return; } - msgpack_sbuffer_destroy(sbuf); - free(sbuf); + if(sbuf == NULL) { return; } + msgpack_sbuffer_destroy(sbuf); + free(sbuf); } #ifndef MSGPACK_SBUFFER_INIT_SIZE @@ -66,39 +66,39 @@ static inline void msgpack_sbuffer_free(msgpack_sbuffer* sbuf) static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len) { - msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data; + msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data; - if(sbuf->alloc - sbuf->size < len) { - void* tmp; - size_t nsize = (sbuf->alloc) ? - sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; + if(sbuf->alloc - sbuf->size < len) { + void* tmp; + size_t nsize = (sbuf->alloc) ? + sbuf->alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - while(nsize < sbuf->size + len) { nsize *= 2; } + while(nsize < sbuf->size + len) { nsize *= 2; } - tmp = realloc(sbuf->data, nsize); - if(!tmp) { return -1; } + tmp = realloc(sbuf->data, nsize); + if(!tmp) { return -1; } - sbuf->data = (char*)tmp; - sbuf->alloc = nsize; - } + sbuf->data = (char*)tmp; + sbuf->alloc = nsize; + } - memcpy(sbuf->data + sbuf->size, buf, len); - sbuf->size += len; - return 0; + memcpy(sbuf->data + sbuf->size, buf, len); + sbuf->size += len; + return 0; } static inline char* msgpack_sbuffer_release(msgpack_sbuffer* sbuf) { - char* tmp = sbuf->data; - sbuf->size = 0; - sbuf->data = NULL; - sbuf->alloc = 0; - return tmp; + char* tmp = sbuf->data; + sbuf->size = 0; + sbuf->data = NULL; + sbuf->alloc = 0; + return tmp; } static inline void msgpack_sbuffer_clear(msgpack_sbuffer* sbuf) { - sbuf->size = 0; + sbuf->size = 0; } /** @} */ diff --git a/include/msgpack/sbuffer.hpp b/include/msgpack/sbuffer.hpp index 427603a3..76f4be25 100644 --- a/include/msgpack/sbuffer.hpp +++ b/include/msgpack/sbuffer.hpp @@ -29,85 +29,85 @@ namespace msgpack { class sbuffer { public: - sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):m_size(0), m_alloc(initsz) - { - if(initsz == 0) { - m_data = nullptr; - } else { - m_data = (char*)::malloc(initsz); - if(!m_data) { - throw std::bad_alloc(); - } - } - } + sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):m_size(0), m_alloc(initsz) + { + if(initsz == 0) { + m_data = nullptr; + } else { + m_data = (char*)::malloc(initsz); + if(!m_data) { + throw std::bad_alloc(); + } + } + } - ~sbuffer() - { - ::free(m_data); - } + ~sbuffer() + { + ::free(m_data); + } public: - void write(const char* buf, size_t len) - { - if(m_alloc - m_size < len) { - expand_buffer(len); - } - ::memcpy(m_data + m_size, buf, len); - m_size += len; - } + void write(const char* buf, size_t len) + { + if(m_alloc - m_size < len) { + expand_buffer(len); + } + ::memcpy(m_data + m_size, buf, len); + m_size += len; + } - char* data() - { - return m_data; - } + char* data() + { + return m_data; + } - const char* data() const - { - return m_data; - } + const char* data() const + { + return m_data; + } - size_t size() const - { - return m_size; - } + size_t size() const + { + return m_size; + } - char* release() - { - char* tmp = m_data; - m_size = 0; - m_data = nullptr; - m_alloc = 0; - return tmp; - } + char* release() + { + char* tmp = m_data; + m_size = 0; + m_data = nullptr; + m_alloc = 0; + return tmp; + } - void clear() - { - m_size = 0; - } + void clear() + { + m_size = 0; + } private: - void expand_buffer(size_t len) - { - size_t nsize = (m_alloc > 0) ? - m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - - while(nsize < m_size + len) { nsize *= 2; } - - void* tmp = ::realloc(m_data, nsize); - if(!tmp) { - throw std::bad_alloc(); - } - - m_data = static_cast(tmp); - m_alloc = nsize; - } + void expand_buffer(size_t len) + { + size_t nsize = (m_alloc > 0) ? + m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; + + while(nsize < m_size + len) { nsize *= 2; } + + void* tmp = ::realloc(m_data, nsize); + if(!tmp) { + throw std::bad_alloc(); + } + + m_data = static_cast(tmp); + m_alloc = nsize; + } private: - sbuffer(const sbuffer&); + sbuffer(const sbuffer&); private: - size_t m_size; - char* m_data; - size_t m_alloc; + size_t m_size; + char* m_data; + size_t m_alloc; }; diff --git a/include/msgpack/unpack.h b/include/msgpack/unpack.h index 92eb346b..b5ad757c 100644 --- a/include/msgpack/unpack.h +++ b/include/msgpack/unpack.h @@ -34,12 +34,12 @@ extern "C" { */ typedef struct msgpack_unpacked { - msgpack_zone* zone; - msgpack_object data; + msgpack_zone* zone; + msgpack_object data; } msgpack_unpacked; bool msgpack_unpack_next(msgpack_unpacked* result, - const char* data, size_t len, size_t* off); + const char* data, size_t len, size_t* off); /** @} */ @@ -51,14 +51,14 @@ bool msgpack_unpack_next(msgpack_unpacked* result, */ typedef struct msgpack_unpacker { - char* buffer; - size_t used; - size_t free; - size_t off; - size_t parsed; - msgpack_zone* z; - size_t initial_buffer_size; - void* ctx; + char* buffer; + size_t used; + size_t free; + size_t off; + size_t parsed; + msgpack_zone* z; + size_t initial_buffer_size; + void* ctx; } msgpack_unpacker; @@ -176,16 +176,16 @@ static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac) // obsolete typedef enum { - MSGPACK_UNPACK_SUCCESS = 2, - MSGPACK_UNPACK_EXTRA_BYTES = 1, - MSGPACK_UNPACK_CONTINUE = 0, - MSGPACK_UNPACK_PARSE_ERROR = -1 + MSGPACK_UNPACK_SUCCESS = 2, + MSGPACK_UNPACK_EXTRA_BYTES = 1, + MSGPACK_UNPACK_CONTINUE = 0, + MSGPACK_UNPACK_PARSE_ERROR = -1 } msgpack_unpack_return; // obsolete msgpack_unpack_return msgpack_unpack(const char* data, size_t len, size_t* off, - msgpack_zone* result_zone, msgpack_object* result); + msgpack_zone* result_zone, msgpack_object* result); static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac); @@ -196,59 +196,59 @@ bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size); static inline bool msgpack_unpacker_reserve_buffer(msgpack_unpacker* mpac, size_t size) { - if(mpac->free >= size) { return true; } - return msgpack_unpacker_expand_buffer(mpac, size); + if(mpac->free >= size) { return true; } + return msgpack_unpacker_expand_buffer(mpac, size); } static inline char* msgpack_unpacker_buffer(msgpack_unpacker* mpac) { - return mpac->buffer + mpac->used; + return mpac->buffer + mpac->used; } static inline size_t msgpack_unpacker_buffer_capacity(const msgpack_unpacker* mpac) { - return mpac->free; + return mpac->free; } static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, size_t size) { - mpac->used += size; - mpac->free -= size; + mpac->used += size; + mpac->free -= size; } static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac) { - return mpac->parsed - mpac->off + mpac->used; + return mpac->parsed - mpac->off + mpac->used; } static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac) { - return mpac->parsed; + return mpac->parsed; } static inline void msgpack_unpacked_init(msgpack_unpacked* result) { - memset(result, 0, sizeof(msgpack_unpacked)); + memset(result, 0, sizeof(msgpack_unpacked)); } static inline void msgpack_unpacked_destroy(msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone_free(result->zone); - result->zone = NULL; - memset(&result->data, 0, sizeof(msgpack_object)); - } + if(result->zone != NULL) { + msgpack_zone_free(result->zone); + result->zone = NULL; + memset(&result->data, 0, sizeof(msgpack_object)); + } } static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone* z = result->zone; - result->zone = NULL; - return z; - } - return NULL; + if(result->zone != NULL) { + msgpack_zone* z = result->zone; + result->zone = NULL; + return z; + } + return NULL; } diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 53066bbc..e2dab058 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -52,14 +52,14 @@ namespace detail { class unpack_user { public: - msgpack::zone const& zone() const { return *m_zone; } - msgpack::zone& zone() { return *m_zone; } - void set_zone(msgpack::zone& zone) { m_zone = &zone; } - bool referenced() const { return m_referenced; } - void set_referenced(bool referenced) { m_referenced = referenced; } + msgpack::zone const& zone() const { return *m_zone; } + msgpack::zone& zone() { return *m_zone; } + void set_zone(msgpack::zone& zone) { m_zone = &zone; } + bool referenced() const { return m_referenced; } + void set_referenced(bool referenced) { m_referenced = referenced; } private: - msgpack::zone* m_zone; - bool m_referenced; + msgpack::zone* m_zone; + bool m_referenced; }; inline void unpack_uint8(uint8_t d, object& o) @@ -76,19 +76,19 @@ inline void unpack_uint64(uint64_t d, object& o) inline void unpack_int8(int8_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } inline void unpack_int16(int16_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } inline void unpack_int32(int32_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } inline void unpack_int64(int64_t d, object& o) { if(d >= 0) { o.type = type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } + else { o.type = type::NEGATIVE_INTEGER; o.via.i64 = d; } } inline void unpack_float(float d, object& o) { o.type = type::DOUBLE; o.via.dec = d; } @@ -106,785 +106,785 @@ inline void unpack_false(object& o) { o.type = type::BOOLEAN; o.via.boolean = false; } struct unpack_array { - bool operator()(unpack_user&u, unsigned int n, object& o) const { - o.type = type::ARRAY; - o.via.array.size = 0; - o.via.array.ptr = static_cast(u.zone().allocate_align(n*sizeof(object))); - if(o.via.array.ptr == nullptr) { return false; } - return true; - } + bool operator()(unpack_user&u, unsigned int n, object& o) const { + o.type = type::ARRAY; + o.via.array.size = 0; + o.via.array.ptr = static_cast(u.zone().allocate_align(n*sizeof(object))); + if(o.via.array.ptr == nullptr) { return false; } + return true; + } }; inline void unpack_array_item(object& c, object const& o) { #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object)); + memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object)); #else /* __GNUC__ && !__clang__ */ - c.via.array.ptr[c.via.array.size++] = o; + c.via.array.ptr[c.via.array.size++] = o; #endif /* __GNUC__ && !__clang__ */ } struct unpack_map { - bool operator()(unpack_user& u, unsigned int n, object& o) const { - o.type = type::MAP; - o.via.map.size = 0; - o.via.map.ptr = static_cast(u.zone().allocate_align(n*sizeof(object_kv))); - if(o.via.map.ptr == nullptr) { return false; } - return true; - } + bool operator()(unpack_user& u, unsigned int n, object& o) const { + o.type = type::MAP; + o.via.map.size = 0; + o.via.map.ptr = static_cast(u.zone().allocate_align(n*sizeof(object_kv))); + if(o.via.map.ptr == nullptr) { return false; } + return true; + } }; inline void unpack_map_item(object& c, object const& k, object const& v) { #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object)); - memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(object)); + memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object)); + memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(object)); #else /* __GNUC__ && !__clang__ */ - c.via.map.ptr[c.via.map.size].key = k; - c.via.map.ptr[c.via.map.size].val = v; + c.via.map.ptr[c.via.map.size].key = k; + c.via.map.ptr[c.via.map.size].val = v; #endif /* __GNUC__ && !__clang__ */ - ++c.via.map.size; + ++c.via.map.size; } inline void unpack_str(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) { - o.type = type::STR; - o.via.str.ptr = p; - o.via.str.size = l; - u.set_referenced(true); + o.type = type::STR; + o.via.str.ptr = p; + o.via.str.size = l; + u.set_referenced(true); } inline void unpack_bin(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) { - o.type = type::BIN; - o.via.bin.ptr = p; - o.via.bin.size = l; - u.set_referenced(true); + o.type = type::BIN; + o.via.bin.ptr = p; + o.via.bin.size = l; + u.set_referenced(true); } class unpack_stack { public: - object const& obj() const { return m_obj; } - object& obj() { return m_obj; } - void set_obj(object const& obj) { m_obj = obj; } - size_t count() const { return m_count; } - void set_count(size_t count) { m_count = count; } - size_t decl_count() { return --m_count; } - unsigned int container_type() const { return m_container_type; } - void set_container_type(unsigned int container_type) { m_container_type = container_type; } - object const& map_key() const { return m_map_key; } - void set_map_key(object const& map_key) { m_map_key = map_key; } + object const& obj() const { return m_obj; } + object& obj() { return m_obj; } + void set_obj(object const& obj) { m_obj = obj; } + size_t count() const { return m_count; } + void set_count(size_t count) { m_count = count; } + size_t decl_count() { return --m_count; } + unsigned int container_type() const { return m_container_type; } + void set_container_type(unsigned int container_type) { m_container_type = container_type; } + object const& map_key() const { return m_map_key; } + void set_map_key(object const& map_key) { m_map_key = map_key; } private: - object m_obj; - size_t m_count; - unsigned int m_container_type; - object m_map_key; + object m_obj; + size_t m_count; + unsigned int m_container_type; + object m_map_key; }; inline void init_count(void* buffer) { - *reinterpret_cast(buffer) = 1; + *reinterpret_cast(buffer) = 1; } inline void decl_count(void* buffer) { - if(_msgpack_sync_decr_and_fetch(reinterpret_cast(buffer)) == 0) { - free(buffer); - } + if(_msgpack_sync_decr_and_fetch(reinterpret_cast(buffer)) == 0) { + free(buffer); + } } inline void incr_count(void* buffer) { - _msgpack_sync_incr_and_fetch(reinterpret_cast(buffer)); + _msgpack_sync_incr_and_fetch(reinterpret_cast(buffer)); } inline _msgpack_atomic_counter_t get_count(void* buffer) { - return *reinterpret_cast(buffer); + return *reinterpret_cast(buffer); } struct fix_tag { - char f1[65]; // FIXME unique size is required. or use is_same meta function. + char f1[65]; // FIXME unique size is required. or use is_same meta function. }; template struct value { - typedef T type; + typedef T type; }; template <> struct value { - typedef unsigned int type; + typedef unsigned int type; }; template inline void load(unsigned int& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - dst = static_cast(*reinterpret_cast(n)) & 0x0f; + dst = static_cast(*reinterpret_cast(n)) & 0x0f; } template inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - dst = static_cast(*reinterpret_cast(n)); + dst = static_cast(*reinterpret_cast(n)); } template inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - _msgpack_load16(T, n, &dst); + _msgpack_load16(T, n, &dst); } template inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - _msgpack_load32(T, n, &dst); + _msgpack_load32(T, n, &dst); } template inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - _msgpack_load64(T, n, &dst); + _msgpack_load64(T, n, &dst); } class context { public: - context():m_trail(0), m_cs(CS_HEADER), m_top(0) - { - m_stack[0].set_obj(object()); - } + context():m_trail(0), m_cs(CS_HEADER), m_top(0) + { + m_stack[0].set_obj(object()); + } - void init() - { - m_cs = CS_HEADER; - m_trail = 0; - m_top = 0; - m_stack[0].set_obj(object()); - } + void init() + { + m_cs = CS_HEADER; + m_trail = 0; + m_top = 0; + m_stack[0].set_obj(object()); + } - object const& data() const - { - return m_stack[0].obj(); - } + object const& data() const + { + return m_stack[0].obj(); + } - unpack_user& user() - { - return m_user; - } + unpack_user& user() + { + return m_user; + } - unpack_user const& user() const - { - return m_user; - } + unpack_user const& user() const + { + return m_user; + } - int execute(const char* data, size_t len, size_t& off) - { - assert(len >= off); + int execute(const char* data, size_t len, size_t& off) + { + assert(len >= off); - m_start = data; - m_current = data + off; - m_stack_idx = 0; - const char* const pe = data + len; - const char* n = nullptr; + m_start = data; + m_current = data + off; + m_stack_idx = 0; + const char* const pe = data + len; + const char* n = nullptr; - object obj; + object obj; - if(m_current == pe) { - off = m_current - m_start; - return 0; - } - bool fixed_trail_again = false; - do { - if (m_cs == CS_HEADER) { - fixed_trail_again = false; - int selector = *reinterpret_cast(m_current); - if (0) { - } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum - unpack_uint8(*reinterpret_cast(m_current), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum - unpack_int8(*reinterpret_cast(m_current), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } else if(0xc0 <= selector && selector <= 0xdf) { // Variable - switch(selector) { - case 0xc0: { // nil - unpack_nil(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - //case 0xc1: // string - case 0xc2: { // false - unpack_false(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case 0xc3: { // true - unpack_true(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case 0xc4: // bin 8 - case 0xc5: // bin 16 - case 0xc6: // bin 32 - m_trail = 1 << (static_cast(*m_current) & 0x03); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; + if(m_current == pe) { + off = m_current - m_start; + return 0; + } + bool fixed_trail_again = false; + do { + if (m_cs == CS_HEADER) { + fixed_trail_again = false; + int selector = *reinterpret_cast(m_current); + if (0) { + } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum + unpack_uint8(*reinterpret_cast(m_current), obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum + unpack_int8(*reinterpret_cast(m_current), obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if(0xc0 <= selector && selector <= 0xdf) { // Variable + switch(selector) { + case 0xc0: { // nil + unpack_nil(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + //case 0xc1: // string + case 0xc2: { // false + unpack_false(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case 0xc3: { // true + unpack_true(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case 0xc4: // bin 8 + case 0xc5: // bin 16 + case 0xc6: // bin 32 + m_trail = 1 << (static_cast(*m_current) & 0x03); + m_cs = next_cs(m_current); + fixed_trail_again = true; + break; - //case 0xc7: - //case 0xc8: - //case 0xc9: - case 0xca: // float - case 0xcb: // double - case 0xcc: // unsigned int 8 - case 0xcd: // unsigned int 16 - case 0xce: // unsigned int 32 - case 0xcf: // unsigned int 64 - case 0xd0: // signed int 8 - case 0xd1: // signed int 16 - case 0xd2: // signed int 32 - case 0xd3: // signed int 64 - m_trail = 1 << (static_cast(*m_current) & 0x03); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - //case 0xd4: - //case 0xd5: - //case 0xd6: // big integer 16 - //case 0xd7: // big integer 32 - //case 0xd8: // big float 16 - case 0xd9: // str 8 - case 0xda: // str 16 - case 0xdb: // str 32 - m_trail = 1 << ((static_cast(*m_current) & 0x03) - 1); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - case 0xdc: // array 16 - case 0xdd: // array 32 - case 0xde: // map 16 - case 0xdf: // map 32 - m_trail = 2 << (static_cast(*m_current) & 0x01); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - default: - off = m_current - m_start; - return -1; - } - } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr - m_trail = static_cast(*m_current) & 0x1f; - if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = ACS_STR_VALUE; - fixed_trail_again = true; - } + //case 0xc7: + //case 0xc8: + //case 0xc9: + case 0xca: // float + case 0xcb: // double + case 0xcc: // unsigned int 8 + case 0xcd: // unsigned int 16 + case 0xce: // unsigned int 32 + case 0xcf: // unsigned int 64 + case 0xd0: // signed int 8 + case 0xd1: // signed int 16 + case 0xd2: // signed int 32 + case 0xd3: // signed int 64 + m_trail = 1 << (static_cast(*m_current) & 0x03); + m_cs = next_cs(m_current); + fixed_trail_again = true; + break; + //case 0xd4: + //case 0xd5: + //case 0xd6: // big integer 16 + //case 0xd7: // big integer 32 + //case 0xd8: // big float 16 + case 0xd9: // str 8 + case 0xda: // str 16 + case 0xdb: // str 32 + m_trail = 1 << ((static_cast(*m_current) & 0x03) - 1); + m_cs = next_cs(m_current); + fixed_trail_again = true; + break; + case 0xdc: // array 16 + case 0xdd: // array 32 + case 0xde: // map 16 + case 0xdf: // map 32 + m_trail = 2 << (static_cast(*m_current) & 0x01); + m_cs = next_cs(m_current); + fixed_trail_again = true; + break; + default: + off = m_current - m_start; + return -1; + } + } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr + m_trail = static_cast(*m_current) & 0x1f; + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } - } else if(0x90 <= selector && selector <= 0x9f) { // FixArray - int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, obj, m_current, off); - if (ret != 0) return ret; - } else if(0x80 <= selector && selector <= 0x8f) { // FixMap - int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, obj, m_current, off); - if (ret != 0) return ret; - } else { - off = m_current - m_start; - return -1; - } - // end CS_HEADER - } - if (m_cs != CS_HEADER || fixed_trail_again) { - if (fixed_trail_again) { - ++m_current; - fixed_trail_again = false; - } - if((size_t)(pe - m_current) < m_trail) { - off = m_current - m_start; - return 0; - } - n = m_current; - m_current += m_trail - 1; - switch(m_cs) { - //case CS_ - //case CS_ - case CS_FLOAT: { - union { uint32_t i; float f; } mem; - load(mem.i, n); - unpack_float(mem.f, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_DOUBLE: { - union { uint64_t i; double f; } mem; - load(mem.i, n); + } else if(0x90 <= selector && selector <= 0x9f) { // FixArray + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, obj, m_current, off); + if (ret != 0) return ret; + } else if(0x80 <= selector && selector <= 0x8f) { // FixMap + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, obj, m_current, off); + if (ret != 0) return ret; + } else { + off = m_current - m_start; + return -1; + } + // end CS_HEADER + } + if (m_cs != CS_HEADER || fixed_trail_again) { + if (fixed_trail_again) { + ++m_current; + fixed_trail_again = false; + } + if((size_t)(pe - m_current) < m_trail) { + off = m_current - m_start; + return 0; + } + n = m_current; + m_current += m_trail - 1; + switch(m_cs) { + //case CS_ + //case CS_ + case CS_FLOAT: { + union { uint32_t i; float f; } mem; + load(mem.i, n); + unpack_float(mem.f, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_DOUBLE: { + union { uint64_t i; double f; } mem; + load(mem.i, n); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); + // https://github.com/msgpack/msgpack-perl/pull/1 + mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - unpack_double(mem.f, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_UINT_8: { - uint8_t tmp; - load(tmp, n); - unpack_uint8(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_UINT_16: { - uint16_t tmp; - load(tmp, n); - unpack_uint16(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_UINT_32: { - uint32_t tmp; - load(tmp, n); - unpack_uint32(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_UINT_64: { - uint64_t tmp; - load(tmp, n); - unpack_uint64(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_INT_8: { - int8_t tmp; - load(tmp, n); - unpack_int8(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_INT_16: { - int16_t tmp; - load(tmp, n); - unpack_int16(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_INT_32: { - int32_t tmp; - load(tmp, n); - unpack_int32(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_INT_64: { - int64_t tmp; - load(tmp, n); - unpack_int64(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_STR_8: { - uint8_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = ACS_STR_VALUE; - fixed_trail_again = true; - } - } break; - case CS_BIN_8: { - uint8_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_bin(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = ACS_BIN_VALUE; - fixed_trail_again = true; - } - } break; - case CS_STR_16: { - uint16_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = ACS_STR_VALUE; - fixed_trail_again = true; - } - } break; - case CS_BIN_16: { - uint16_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_bin(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = ACS_BIN_VALUE; - fixed_trail_again = true; - } - } break; - case CS_STR_32: - load(m_trail, n); - if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = ACS_STR_VALUE; - fixed_trail_again = true; - } - break; - case CS_BIN_32: - load(m_trail, n); - if(m_trail == 0) { - unpack_bin(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = ACS_BIN_VALUE; - fixed_trail_again = true; - } - break; - case ACS_STR_VALUE: { - unpack_str(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case ACS_BIN_VALUE: { - unpack_bin(m_user, data, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case CS_ARRAY_16: { - int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, obj, n, off); - if (ret != 0) return ret; - } break; - case CS_ARRAY_32: { - /* FIXME security guard */ - int ret = push_aggregate( - unpack_array(), CT_ARRAY_ITEM, obj, n, off); - if (ret != 0) return ret; - } break; - case CS_MAP_16: { - int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, obj, n, off); - if (ret != 0) return ret; - } break; - case CS_MAP_32: { - /* FIXME security guard */ - int ret = push_aggregate( - unpack_map(), CT_MAP_KEY, obj, n, off); - if (ret != 0) return ret; - } break; - default: - off = m_current - m_start; - return -1; - } - } - } while(m_current != pe); + unpack_double(mem.f, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_8: { + uint8_t tmp; + load(tmp, n); + unpack_uint8(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_16: { + uint16_t tmp; + load(tmp, n); + unpack_uint16(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_32: { + uint32_t tmp; + load(tmp, n); + unpack_uint32(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_UINT_64: { + uint64_t tmp; + load(tmp, n); + unpack_uint64(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_8: { + int8_t tmp; + load(tmp, n); + unpack_int8(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_16: { + int16_t tmp; + load(tmp, n); + unpack_int16(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_32: { + int32_t tmp; + load(tmp, n); + unpack_int32(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_INT_64: { + int64_t tmp; + load(tmp, n); + unpack_int64(tmp, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_STR_8: { + uint8_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } + } break; + case CS_BIN_8: { + uint8_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_bin(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_BIN_VALUE; + fixed_trail_again = true; + } + } break; + case CS_STR_16: { + uint16_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } + } break; + case CS_BIN_16: { + uint16_t tmp; + load(tmp, n); + m_trail = tmp; + if(m_trail == 0) { + unpack_bin(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_BIN_VALUE; + fixed_trail_again = true; + } + } break; + case CS_STR_32: + load(m_trail, n); + if(m_trail == 0) { + unpack_str(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_STR_VALUE; + fixed_trail_again = true; + } + break; + case CS_BIN_32: + load(m_trail, n); + if(m_trail == 0) { + unpack_bin(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_BIN_VALUE; + fixed_trail_again = true; + } + break; + case ACS_STR_VALUE: { + unpack_str(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case ACS_BIN_VALUE: { + unpack_bin(m_user, data, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_ARRAY_16: { + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, obj, n, off); + if (ret != 0) return ret; + } break; + case CS_ARRAY_32: { + /* FIXME security guard */ + int ret = push_aggregate( + unpack_array(), CT_ARRAY_ITEM, obj, n, off); + if (ret != 0) return ret; + } break; + case CS_MAP_16: { + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, obj, n, off); + if (ret != 0) return ret; + } break; + case CS_MAP_32: { + /* FIXME security guard */ + int ret = push_aggregate( + unpack_map(), CT_MAP_KEY, obj, n, off); + if (ret != 0) return ret; + } break; + default: + off = m_current - m_start; + return -1; + } + } + } while(m_current != pe); - off = m_current - m_start; - return 0; - } + off = m_current - m_start; + return 0; + } private: - template - static unsigned int next_cs(T p) - { - return static_cast(*p) & 0x1f; - } + template + static unsigned int next_cs(T p) + { + return static_cast(*p) & 0x1f; + } - template - int push_aggregate( - Func const& f, - unsigned int container_type, - object& obj, - const char* load_pos, - size_t& off) { - if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { - typename value::type tmp; - load(tmp, load_pos); - if (f(m_user, tmp, m_stack[m_top].obj())) { - if(tmp == 0) { - obj = m_stack[m_top].obj(); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_stack[m_top].set_container_type(container_type); - m_stack[m_top].set_count(tmp); - ++m_top; - m_cs = CS_HEADER; - ++m_current; - } - } - else { - off = m_current - m_start; - return -1; - } - } - else { - off = m_current - m_start; - return -1; - } - return 0; - } + template + int push_aggregate( + Func const& f, + unsigned int container_type, + object& obj, + const char* load_pos, + size_t& off) { + if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { + typename value::type tmp; + load(tmp, load_pos); + if (f(m_user, tmp, m_stack[m_top].obj())) { + if(tmp == 0) { + obj = m_stack[m_top].obj(); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_stack[m_top].set_container_type(container_type); + m_stack[m_top].set_count(tmp); + ++m_top; + m_cs = CS_HEADER; + ++m_current; + } + } + else { + off = m_current - m_start; + return -1; + } + } + else { + off = m_current - m_start; + return -1; + } + return 0; + } - int push_item(object& obj) { - bool finish = false; - while (!finish) { - if(m_top == 0) { - return 1; - } - m_stack_idx = m_top - 1; - unpack_stack* sp = &m_stack[m_stack_idx]; - switch(sp->container_type()) { - case CT_ARRAY_ITEM: - unpack_array_item(sp->obj(), obj); - if(sp->decl_count() == 0) { - obj = sp->obj(); - --m_top; - /*printf("stack pop %d\n", m_top);*/ - } - else { - finish = true; - } - break; - case CT_MAP_KEY: - sp->set_map_key(obj); - sp->set_container_type(CT_MAP_VALUE); - finish = true; - break; - case CT_MAP_VALUE: - unpack_map_item(sp->obj(), sp->map_key(), obj); - if(sp->decl_count() == 0) { - obj = sp->obj(); - --m_top; - /*printf("stack pop %d\n", m_top);*/ - } - else { - sp->set_container_type(CT_MAP_KEY); - finish = true; - } - break; - default: - return -1; - } - } - return 0; - } + int push_item(object& obj) { + bool finish = false; + while (!finish) { + if(m_top == 0) { + return 1; + } + m_stack_idx = m_top - 1; + unpack_stack* sp = &m_stack[m_stack_idx]; + switch(sp->container_type()) { + case CT_ARRAY_ITEM: + unpack_array_item(sp->obj(), obj); + if(sp->decl_count() == 0) { + obj = sp->obj(); + --m_top; + /*printf("stack pop %d\n", m_top);*/ + } + else { + finish = true; + } + break; + case CT_MAP_KEY: + sp->set_map_key(obj); + sp->set_container_type(CT_MAP_VALUE); + finish = true; + break; + case CT_MAP_VALUE: + unpack_map_item(sp->obj(), sp->map_key(), obj); + if(sp->decl_count() == 0) { + obj = sp->obj(); + --m_top; + /*printf("stack pop %d\n", m_top);*/ + } + else { + sp->set_container_type(CT_MAP_KEY); + finish = true; + } + break; + default: + return -1; + } + } + return 0; + } - int push_proc(object& obj, size_t& off) { - int ret = push_item(obj); - if (ret > 0) { - m_stack[0].set_obj(obj); - ++m_current; - /*printf("-- finish --\n"); */ - off = m_current - m_start; - } - else if (ret < 0) { - off = m_current - m_start; - } - else { - m_cs = CS_HEADER; - ++m_current; - } - return ret; - } + int push_proc(object& obj, size_t& off) { + int ret = push_item(obj); + if (ret > 0) { + m_stack[0].set_obj(obj); + ++m_current; + /*printf("-- finish --\n"); */ + off = m_current - m_start; + } + else if (ret < 0) { + off = m_current - m_start; + } + else { + m_cs = CS_HEADER; + ++m_current; + } + return ret; + } private: - char const* m_start; - char const* m_current; + char const* m_start; + char const* m_current; - unsigned int m_trail; - unpack_user m_user; - unsigned int m_cs; - unsigned int m_top; - unsigned int m_stack_idx; - unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE]; + unsigned int m_trail; + unpack_user m_user; + unsigned int m_cs; + unsigned int m_top; + unsigned int m_stack_idx; + unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE]; }; } // detail struct unpack_error : public std::runtime_error { - unpack_error(const std::string& msg) : - std::runtime_error(msg) { } + unpack_error(const std::string& msg) : + std::runtime_error(msg) { } }; class unpacked { public: - unpacked() { } + unpacked() { } - unpacked(object const& obj, msgpack::unique_ptr z) : - m_obj(obj), m_zone(msgpack::move(z)) { } + unpacked(object const& obj, msgpack::unique_ptr z) : + m_obj(obj), m_zone(msgpack::move(z)) { } - void set(object const& obj) - { m_obj = obj; } + void set(object const& obj) + { m_obj = obj; } - const object& get() const - { return m_obj; } + const object& get() const + { return m_obj; } - msgpack::unique_ptr& zone() - { return m_zone; } + msgpack::unique_ptr& zone() + { return m_zone; } - const msgpack::unique_ptr& zone() const - { return m_zone; } + const msgpack::unique_ptr& zone() const + { return m_zone; } private: - object m_obj; - msgpack::unique_ptr m_zone; + object m_obj; + msgpack::unique_ptr m_zone; }; class unpacker { public: - unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); - ~unpacker(); + unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + ~unpacker(); public: - /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ - void reserve_buffer(size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); + /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ + void reserve_buffer(size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); - /*! 2. read data to the buffer() up to buffer_capacity() bytes */ - char* buffer(); - size_t buffer_capacity() const; + /*! 2. read data to the buffer() up to buffer_capacity() bytes */ + char* buffer(); + size_t buffer_capacity() const; - /*! 3. specify the number of bytes actually copied */ - void buffer_consumed(size_t size); + /*! 3. specify the number of bytes actually copied */ + void buffer_consumed(size_t size); - /*! 4. repeat next() until it retunrs false */ - bool next(unpacked* result); + /*! 4. repeat next() until it retunrs false */ + bool next(unpacked* result); - /*! 5. check if the size of message doesn't exceed assumption. */ - size_t message_size() const; + /*! 5. check if the size of message doesn't exceed assumption. */ + size_t message_size() const; - // Basic usage of the unpacker is as following: - // - // unpacker pac; - // while( /* input is readable */ ) { - // - // // 1. - // pac.reserve_buffer(32*1024); - // - // // 2. - // size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity()); - // - // // error handling ... - // - // // 3. - // pac.buffer_consumed(bytes); - // - // // 4. - // unpacked result; - // while(pac.next(&result)) { - // // do some with the object with the zone. - // object obj = result.get(); - // std::auto_ptr z = result.zone(); - // on_message(obj, z); - // - // //// boost::shared_ptr is also usable: - // // boost::shared_ptr life(z.release()); - // // on_message(result.get(), life); - // } - // - // // 5. - // if(pac.message_size() > 10*1024*1024) { - // throw std::runtime_error("message is too large"); - // } - // } - // + // Basic usage of the unpacker is as following: + // + // unpacker pac; + // while( /* input is readable */ ) { + // + // // 1. + // pac.reserve_buffer(32*1024); + // + // // 2. + // size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity()); + // + // // error handling ... + // + // // 3. + // pac.buffer_consumed(bytes); + // + // // 4. + // unpacked result; + // while(pac.next(&result)) { + // // do some with the object with the zone. + // object obj = result.get(); + // std::auto_ptr z = result.zone(); + // on_message(obj, z); + // + // //// boost::shared_ptr is also usable: + // // boost::shared_ptr life(z.release()); + // // on_message(result.get(), life); + // } + // + // // 5. + // if(pac.message_size() > 10*1024*1024) { + // throw std::runtime_error("message is too large"); + // } + // } + // - /*! for backward compatibility */ - bool execute(); + /*! for backward compatibility */ + bool execute(); - /*! for backward compatibility */ - object const& data(); + /*! for backward compatibility */ + object const& data(); - /*! for backward compatibility */ - zone* release_zone(); + /*! for backward compatibility */ + zone* release_zone(); - /*! for backward compatibility */ - void reset_zone(); + /*! for backward compatibility */ + void reset_zone(); - /*! for backward compatibility */ - void reset(); + /*! for backward compatibility */ + void reset(); public: - // These functions are usable when non-MessagePack message follows after - // MessagePack message. - size_t parsed_size() const; + // These functions are usable when non-MessagePack message follows after + // MessagePack message. + size_t parsed_size() const; - /*! get address of the buffer that is not parsed */ - char* nonparsed_buffer(); - size_t nonparsed_size() const; + /*! get address of the buffer that is not parsed */ + char* nonparsed_buffer(); + size_t nonparsed_size() const; - /*! skip specified size of non-parsed buffer, leaving the buffer */ - // Note that the `size' argument must be smaller than nonparsed_size() - void skip_nonparsed_buffer(size_t size); + /*! skip specified size of non-parsed buffer, leaving the buffer */ + // Note that the `size' argument must be smaller than nonparsed_size() + void skip_nonparsed_buffer(size_t size); - /*! remove unparsed buffer from unpacker */ - // Note that reset() leaves non-parsed buffer. - void remove_nonparsed_buffer(); + /*! remove unparsed buffer from unpacker */ + // Note that reset() leaves non-parsed buffer. + void remove_nonparsed_buffer(); private: - void expand_buffer(size_t size); - int execute_imp(); - bool flush_zone(); + void expand_buffer(size_t size); + int execute_imp(); + bool flush_zone(); private: - char* m_buffer; - size_t m_used; - size_t m_free; - size_t m_off; - size_t m_parsed; - zone* m_z; - size_t m_initial_buffer_size; - detail::context m_ctx; + char* m_buffer; + size_t m_used; + size_t m_free; + size_t m_off; + size_t m_parsed; + zone* m_z; + size_t m_initial_buffer_size; + detail::context m_ctx; private: - unpacker(const unpacker&); + unpacker(const unpacker&); }; inline void unpack(unpacked& result, - const char* data, size_t len, size_t* offset = nullptr); + const char* data, size_t len, size_t* offset = nullptr); inline void unpack(unpacked* result, - const char* data, size_t len, size_t* offset = nullptr); + const char* data, size_t len, size_t* offset = nullptr); // obsolete typedef enum { - UNPACK_SUCCESS = 2, - UNPACK_EXTRA_BYTES = 1, - UNPACK_CONTINUE = 0, - UNPACK_PARSE_ERROR = -1 + UNPACK_SUCCESS = 2, + UNPACK_EXTRA_BYTES = 1, + UNPACK_CONTINUE = 0, + UNPACK_PARSE_ERROR = -1 } unpack_return; // obsolete static unpack_return unpack(const char* data, size_t len, size_t* off, - zone& z, object& result); + zone& z, object& result); static unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result); + zone* z, object* result); // obsolete @@ -894,375 +894,375 @@ static object unpack(const char* data, size_t len, zone* z, size_t* off = nullpt inline unpacker::unpacker(size_t initial_buffer_size) { - if(initial_buffer_size < COUNTER_SIZE) { - initial_buffer_size = COUNTER_SIZE; - } + if(initial_buffer_size < COUNTER_SIZE) { + initial_buffer_size = COUNTER_SIZE; + } - char* buffer = static_cast(::malloc(initial_buffer_size)); - if(!buffer) { - throw std::bad_alloc(); - } + char* buffer = static_cast(::malloc(initial_buffer_size)); + if(!buffer) { + throw std::bad_alloc(); + } - zone* z = zone::create(MSGPACK_ZONE_CHUNK_SIZE); - if(!z) { - ::free(buffer); - throw std::bad_alloc(); - } + zone* z = zone::create(MSGPACK_ZONE_CHUNK_SIZE); + if(!z) { + ::free(buffer); + throw std::bad_alloc(); + } - m_buffer = buffer; - m_used = COUNTER_SIZE; - m_free = initial_buffer_size - m_used; - m_off = COUNTER_SIZE; - m_parsed = 0; - m_initial_buffer_size = initial_buffer_size; - m_z = z; + m_buffer = buffer; + m_used = COUNTER_SIZE; + m_free = initial_buffer_size - m_used; + m_off = COUNTER_SIZE; + m_parsed = 0; + m_initial_buffer_size = initial_buffer_size; + m_z = z; - detail::init_count(m_buffer); + detail::init_count(m_buffer); - m_ctx.init(); - m_ctx.user().set_zone(*m_z); - m_ctx.user().set_referenced(false); + m_ctx.init(); + m_ctx.user().set_zone(*m_z); + m_ctx.user().set_referenced(false); } inline unpacker::~unpacker() { - zone::destroy(m_z); - detail::decl_count(m_buffer); + zone::destroy(m_z); + detail::decl_count(m_buffer); } inline void unpacker::reserve_buffer(size_t size) { - if(m_free >= size) return; - expand_buffer(size); + if(m_free >= size) return; + expand_buffer(size); } inline void unpacker::expand_buffer(size_t size) { - if(m_used == m_off && detail::get_count(m_buffer) == 1 - && !m_ctx.user().referenced()) { - // rewind buffer - m_free += m_used - COUNTER_SIZE; - m_used = COUNTER_SIZE; - m_off = COUNTER_SIZE; + if(m_used == m_off && detail::get_count(m_buffer) == 1 + && !m_ctx.user().referenced()) { + // rewind buffer + m_free += m_used - COUNTER_SIZE; + m_used = COUNTER_SIZE; + m_off = COUNTER_SIZE; - if(m_free >= size) return; - } + if(m_free >= size) return; + } - if(m_off == COUNTER_SIZE) { - size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE - while(next_size < size + m_used) { - next_size *= 2; - } + if(m_off == COUNTER_SIZE) { + size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE + while(next_size < size + m_used) { + next_size *= 2; + } - char* tmp = static_cast(::realloc(m_buffer, next_size)); - if(!tmp) { - throw std::bad_alloc(); - } + char* tmp = static_cast(::realloc(m_buffer, next_size)); + if(!tmp) { + throw std::bad_alloc(); + } - m_buffer = tmp; - m_free = next_size - m_used; + m_buffer = tmp; + m_free = next_size - m_used; - } else { - size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE - size_t not_parsed = m_used - m_off; - while(next_size < size + not_parsed + COUNTER_SIZE) { - next_size *= 2; - } + } else { + size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE + size_t not_parsed = m_used - m_off; + while(next_size < size + not_parsed + COUNTER_SIZE) { + next_size *= 2; + } - char* tmp = static_cast(::malloc(next_size)); - if(!tmp) { - throw std::bad_alloc(); - } + char* tmp = static_cast(::malloc(next_size)); + if(!tmp) { + throw std::bad_alloc(); + } - detail::init_count(tmp); + detail::init_count(tmp); - ::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); + ::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); - if(m_ctx.user().referenced()) { - try { - m_z->push_finalizer(&detail::decl_count, m_buffer); - } - catch (...) { - ::free(tmp); - throw; - } - m_ctx.user().set_referenced(false); - } else { - detail::decl_count(m_buffer); - } + if(m_ctx.user().referenced()) { + try { + m_z->push_finalizer(&detail::decl_count, m_buffer); + } + catch (...) { + ::free(tmp); + throw; + } + m_ctx.user().set_referenced(false); + } else { + detail::decl_count(m_buffer); + } - m_buffer = tmp; - m_used = not_parsed + COUNTER_SIZE; - m_free = next_size - m_used; - m_off = COUNTER_SIZE; - } + m_buffer = tmp; + m_used = not_parsed + COUNTER_SIZE; + m_free = next_size - m_used; + m_off = COUNTER_SIZE; + } } inline char* unpacker::buffer() { - return m_buffer + m_used; + return m_buffer + m_used; } inline size_t unpacker::buffer_capacity() const { - return m_free; + return m_free; } inline void unpacker::buffer_consumed(size_t size) { - m_used += size; - m_free -= size; + m_used += size; + m_free -= size; } inline bool unpacker::next(unpacked* result) { - int ret = execute_imp(); + int ret = execute_imp(); - if(ret < 0) { - throw unpack_error("parse error"); - } + if(ret < 0) { + throw unpack_error("parse error"); + } - if(ret == 0) { - result->zone().reset(); - result->set(object()); - return false; + if(ret == 0) { + result->zone().reset(); + result->set(object()); + return false; - } else { - result->zone().reset( release_zone() ); - result->set(data()); - reset(); - return true; - } + } else { + result->zone().reset( release_zone() ); + result->set(data()); + reset(); + return true; + } } inline bool unpacker::execute() { - int ret = execute_imp(); - if(ret < 0) { - throw unpack_error("parse error"); - } else if(ret == 0) { - return false; - } else { - return true; - } + int ret = execute_imp(); + if(ret < 0) { + throw unpack_error("parse error"); + } else if(ret == 0) { + return false; + } else { + return true; + } } inline int unpacker::execute_imp() { - size_t off = m_off; - int ret = m_ctx.execute(m_buffer, m_used, m_off); - if(m_off > off) { - m_parsed += m_off - off; - } - return ret; + size_t off = m_off; + int ret = m_ctx.execute(m_buffer, m_used, m_off); + if(m_off > off) { + m_parsed += m_off - off; + } + return ret; } inline object const& unpacker::data() { - return m_ctx.data(); + return m_ctx.data(); } inline zone* unpacker::release_zone() { - if(!flush_zone()) { - return nullptr; - } + if(!flush_zone()) { + return nullptr; + } - zone* r = zone::create(MSGPACK_ZONE_CHUNK_SIZE); - if(!r) { - return nullptr; - } + zone* r = zone::create(MSGPACK_ZONE_CHUNK_SIZE); + if(!r) { + return nullptr; + } - zone* old = m_z; - m_z = r; - m_ctx.user().set_zone(*m_z); + zone* old = m_z; + m_z = r; + m_ctx.user().set_zone(*m_z); - return old; + return old; } inline void unpacker::reset_zone() { - m_z->clear(); + m_z->clear(); } inline bool unpacker::flush_zone() { - if(m_ctx.user().referenced()) { - try { - m_z->push_finalizer(&detail::decl_count, m_buffer); - } catch (...) { - return false; - } - m_ctx.user().set_referenced(false); + if(m_ctx.user().referenced()) { + try { + m_z->push_finalizer(&detail::decl_count, m_buffer); + } catch (...) { + return false; + } + m_ctx.user().set_referenced(false); - detail::incr_count(m_buffer); - } + detail::incr_count(m_buffer); + } - return true; + return true; } inline void unpacker::reset() { - m_ctx.init(); - // don't reset referenced flag - m_parsed = 0; + m_ctx.init(); + // don't reset referenced flag + m_parsed = 0; } inline size_t unpacker::message_size() const { - return m_parsed - m_off + m_used; + return m_parsed - m_off + m_used; } inline size_t unpacker::parsed_size() const { - return m_parsed; + return m_parsed; } inline char* unpacker::nonparsed_buffer() { - return m_buffer + m_off; + return m_buffer + m_off; } inline size_t unpacker::nonparsed_size() const { - return m_used - m_off; + return m_used - m_off; } inline void unpacker::skip_nonparsed_buffer(size_t size) { - m_off += size; + m_off += size; } inline void unpacker::remove_nonparsed_buffer() { - m_used = m_off; + m_used = m_off; } namespace detail { inline unpack_return unpack_imp(const char* data, size_t len, size_t* off, - zone& result_zone, object& result) + zone& result_zone, object& result) { - size_t noff = 0; - if(off != nullptr) { noff = *off; } + size_t noff = 0; + if(off != nullptr) { noff = *off; } - if(len <= noff) { - // FIXME - return UNPACK_CONTINUE; - } + if(len <= noff) { + // FIXME + return UNPACK_CONTINUE; + } - detail::context ctx; - ctx.init(); + detail::context ctx; + ctx.init(); - ctx.user().set_zone(result_zone); - ctx.user().set_referenced(false); + ctx.user().set_zone(result_zone); + ctx.user().set_referenced(false); - int e = ctx.execute(data, len, noff); - if(e < 0) { - return UNPACK_PARSE_ERROR; - } + int e = ctx.execute(data, len, noff); + if(e < 0) { + return UNPACK_PARSE_ERROR; + } - if(off != nullptr) { *off = noff; } + if(off != nullptr) { *off = noff; } - if(e == 0) { - return UNPACK_CONTINUE; - } + if(e == 0) { + return UNPACK_CONTINUE; + } - result = ctx.data(); + result = ctx.data(); - if(noff < len) { - return UNPACK_EXTRA_BYTES; - } + if(noff < len) { + return UNPACK_EXTRA_BYTES; + } - return UNPACK_SUCCESS; + return UNPACK_SUCCESS; } } // detail // reference version inline void unpack(unpacked& result, - const char* data, size_t len, size_t* offset) + const char* data, size_t len, size_t* offset) { - object obj; - msgpack::unique_ptr z(new zone()); + object obj; + msgpack::unique_ptr z(new zone()); - unpack_return ret = detail::unpack_imp( - data, len, offset, *z, obj); + unpack_return ret = detail::unpack_imp( + data, len, offset, *z, obj); - switch(ret) { - case UNPACK_SUCCESS: - result.set(obj); - result.zone() = msgpack::move(z); - return; + switch(ret) { + case UNPACK_SUCCESS: + result.set(obj); + result.zone() = msgpack::move(z); + return; - case UNPACK_EXTRA_BYTES: - result.set(obj); - result.zone() = msgpack::move(z); - return; + case UNPACK_EXTRA_BYTES: + result.set(obj); + result.zone() = msgpack::move(z); + return; - case UNPACK_CONTINUE: - throw unpack_error("insufficient bytes"); + case UNPACK_CONTINUE: + throw unpack_error("insufficient bytes"); - case UNPACK_PARSE_ERROR: - default: - throw unpack_error("parse error"); - } + case UNPACK_PARSE_ERROR: + default: + throw unpack_error("parse error"); + } } // pointer version inline void unpack(unpacked* result, - const char* data, size_t len, size_t* offset) { - unpack(*result, data, len, offset); + const char* data, size_t len, size_t* offset) { + unpack(*result, data, len, offset); } // obsolete // reference version inline unpack_return unpack(const char* data, size_t len, size_t* off, - zone& z, object& result) + zone& z, object& result) { - return detail::unpack_imp(data, len, off, - z, result); + return detail::unpack_imp(data, len, off, + z, result); } // pointer version inline unpack_return unpack(const char* data, size_t len, size_t* off, - zone* z, object* result) + zone* z, object* result) { - return unpack(data, len, off, *z, *result); + return unpack(data, len, off, *z, *result); } // obsolete // reference version inline object unpack(const char* data, size_t len, zone& z, size_t* off) { - object result; + object result; - switch( unpack(data, len, off, z, result) ) { - case UNPACK_SUCCESS: - return result; + switch( unpack(data, len, off, z, result) ) { + case UNPACK_SUCCESS: + return result; - case UNPACK_EXTRA_BYTES: - if(off) { - return result; - } else { - throw unpack_error("extra bytes"); - } + case UNPACK_EXTRA_BYTES: + if(off) { + return result; + } else { + throw unpack_error("extra bytes"); + } - case UNPACK_CONTINUE: - throw unpack_error("insufficient bytes"); + case UNPACK_CONTINUE: + throw unpack_error("insufficient bytes"); - case UNPACK_PARSE_ERROR: - default: - throw unpack_error("parse error"); - } + case UNPACK_PARSE_ERROR: + default: + throw unpack_error("parse error"); + } } // pointer version inline object unpack(const char* data, size_t len, zone* z, size_t* off) { - return unpack(data, len, *z, off); + return unpack(data, len, *z, off); } } // namespace msgpack diff --git a/include/msgpack/unpack_define.h b/include/msgpack/unpack_define.h index edc60b61..182137f8 100644 --- a/include/msgpack/unpack_define.h +++ b/include/msgpack/unpack_define.h @@ -35,56 +35,56 @@ extern "C" { typedef enum { - CS_HEADER = 0x00, // nil + CS_HEADER = 0x00, // nil - //CS_ = 0x01, - //CS_ = 0x02, // false - //CS_ = 0x03, // true + //CS_ = 0x01, + //CS_ = 0x02, // false + //CS_ = 0x03, // true - CS_BIN_8 = 0x04, - CS_BIN_16 = 0x05, - CS_BIN_32 = 0x06, + CS_BIN_8 = 0x04, + CS_BIN_16 = 0x05, + CS_BIN_32 = 0x06, - //CS_EXT_8 = 0x07, - //CS_EXT_16 = 0x08, - //CS_EXT_32 = 0x09, + //CS_EXT_8 = 0x07, + //CS_EXT_16 = 0x08, + //CS_EXT_32 = 0x09, - CS_FLOAT = 0x0a, - CS_DOUBLE = 0x0b, - CS_UINT_8 = 0x0c, - CS_UINT_16 = 0x0d, - CS_UINT_32 = 0x0e, - CS_UINT_64 = 0x0f, - CS_INT_8 = 0x10, - CS_INT_16 = 0x11, - CS_INT_32 = 0x12, - CS_INT_64 = 0x13, + CS_FLOAT = 0x0a, + CS_DOUBLE = 0x0b, + CS_UINT_8 = 0x0c, + CS_UINT_16 = 0x0d, + CS_UINT_32 = 0x0e, + CS_UINT_64 = 0x0f, + CS_INT_8 = 0x10, + CS_INT_16 = 0x11, + CS_INT_32 = 0x12, + CS_INT_64 = 0x13, - //CS_FIXEXT_1 = 0x14, - //CS_FIXEXT_2 = 0x15, - //CS_FIXEXT_4 = 0x16, - //CS_FIXEXT_8 = 0x17, - //CS_FIXEXT_16 = 0x18, + //CS_FIXEXT_1 = 0x14, + //CS_FIXEXT_2 = 0x15, + //CS_FIXEXT_4 = 0x16, + //CS_FIXEXT_8 = 0x17, + //CS_FIXEXT_16 = 0x18, - CS_STR_8 = 0x19, // str8 - CS_STR_16 = 0x1a, // str16 - CS_STR_32 = 0x1b, // str32 - CS_ARRAY_16 = 0x1c, - CS_ARRAY_32 = 0x1d, - CS_MAP_16 = 0x1e, - CS_MAP_32 = 0x1f, + CS_STR_8 = 0x19, // str8 + CS_STR_16 = 0x1a, // str16 + CS_STR_32 = 0x1b, // str32 + CS_ARRAY_16 = 0x1c, + CS_ARRAY_32 = 0x1d, + CS_MAP_16 = 0x1e, + CS_MAP_32 = 0x1f, - //ACS_BIG_INT_VALUE, - //ACS_BIG_FLOAT_VALUE, - ACS_STR_VALUE, - ACS_BIN_VALUE + //ACS_BIG_INT_VALUE, + //ACS_BIG_FLOAT_VALUE, + ACS_STR_VALUE, + ACS_BIN_VALUE } msgpack_unpack_state; typedef enum { - CT_ARRAY_ITEM, - CT_MAP_KEY, - CT_MAP_VALUE + CT_ARRAY_ITEM, + CT_MAP_KEY, + CT_MAP_VALUE } msgpack_container_type; diff --git a/include/msgpack/unpack_template.h b/include/msgpack/unpack_template.h index 813021e4..598f552f 100644 --- a/include/msgpack/unpack_template.h +++ b/include/msgpack/unpack_template.h @@ -47,128 +47,128 @@ #endif msgpack_unpack_struct_decl(_stack) { - msgpack_unpack_object obj; - size_t count; - unsigned int ct; - msgpack_unpack_object map_key; + msgpack_unpack_object obj; + size_t count; + unsigned int ct; + msgpack_unpack_object map_key; }; msgpack_unpack_struct_decl(_context) { - msgpack_unpack_user user; - unsigned int cs; - unsigned int trail; - unsigned int top; - /* - msgpack_unpack_struct(_stack)* stack; - unsigned int stack_size; - msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE]; - */ - msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE]; + msgpack_unpack_user user; + unsigned int cs; + unsigned int trail; + unsigned int top; + /* + msgpack_unpack_struct(_stack)* stack; + unsigned int stack_size; + msgpack_unpack_struct(_stack) embed_stack[MSGPACK_EMBED_STACK_SIZE]; + */ + msgpack_unpack_struct(_stack) stack[MSGPACK_EMBED_STACK_SIZE]; }; msgpack_unpack_func(void, _init)(msgpack_unpack_struct(_context)* ctx) { - ctx->cs = CS_HEADER; - ctx->trail = 0; - ctx->top = 0; - /* - ctx->stack = ctx->embed_stack; - ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; - */ - ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); + ctx->cs = CS_HEADER; + ctx->trail = 0; + ctx->top = 0; + /* + ctx->stack = ctx->embed_stack; + ctx->stack_size = MSGPACK_EMBED_STACK_SIZE; + */ + ctx->stack[0].obj = msgpack_unpack_callback(_root)(&ctx->user); } /* msgpack_unpack_func(void, _destroy)(msgpack_unpack_struct(_context)* ctx) { - if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) { - free(ctx->stack); - } + if(ctx->stack_size != MSGPACK_EMBED_STACK_SIZE) { + free(ctx->stack); + } } */ msgpack_unpack_func(msgpack_unpack_object, _data)(msgpack_unpack_struct(_context)* ctx) { - return (ctx)->stack[0].obj; + return (ctx)->stack[0].obj; } msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const char* data, size_t len, size_t* off) { - assert(len >= *off); + assert(len >= *off); - const unsigned char* p = (unsigned char*)data + *off; - const unsigned char* const pe = (unsigned char*)data + len; - const void* n = NULL; + const unsigned char* p = (unsigned char*)data + *off; + const unsigned char* const pe = (unsigned char*)data + len; + const void* n = NULL; - unsigned int trail = ctx->trail; - unsigned int cs = ctx->cs; - unsigned int top = ctx->top; - msgpack_unpack_struct(_stack)* stack = ctx->stack; - /* - unsigned int stack_size = ctx->stack_size; - */ - msgpack_unpack_user* user = &ctx->user; + unsigned int trail = ctx->trail; + unsigned int cs = ctx->cs; + unsigned int top = ctx->top; + msgpack_unpack_struct(_stack)* stack = ctx->stack; + /* + unsigned int stack_size = ctx->stack_size; + */ + msgpack_unpack_user* user = &ctx->user; - msgpack_unpack_object obj; - msgpack_unpack_struct(_stack)* c = NULL; + msgpack_unpack_object obj; + msgpack_unpack_struct(_stack)* c = NULL; - int ret; + int ret; #define push_simple_value(func) \ - if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \ - goto _push + if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \ + goto _push #define push_fixed_value(func, arg) \ - if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \ - goto _push + if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \ + goto _push #define push_variable_value(func, base, pos, len) \ - if(msgpack_unpack_callback(func)(user, \ - (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \ - goto _push + if(msgpack_unpack_callback(func)(user, \ + (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \ + goto _push #define again_fixed_trail(_cs, trail_len) \ - trail = trail_len; \ - cs = _cs; \ - goto _fixed_trail_again + trail = trail_len; \ + cs = _cs; \ + goto _fixed_trail_again #define again_fixed_trail_if_zero(_cs, trail_len, ifzero) \ - trail = trail_len; \ - if(trail == 0) { goto ifzero; } \ - cs = _cs; \ - goto _fixed_trail_again + trail = trail_len; \ + if(trail == 0) { goto ifzero; } \ + cs = _cs; \ + goto _fixed_trail_again #define start_container(func, count_, ct_) \ - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \ - if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \ - if((count_) == 0) { obj = stack[top].obj; goto _push; } \ - stack[top].ct = ct_; \ - stack[top].count = count_; \ - ++top; \ - /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \ - /*printf("stack push %d\n", top);*/ \ - /* FIXME \ - if(top >= stack_size) { \ - if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \ - size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \ - size_t nsize = csize * 2; \ - msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \ - if(tmp == NULL) { goto _failed; } \ - memcpy(tmp, ctx->stack, csize); \ - ctx->stack = stack = tmp; \ - ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \ - } else { \ - size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \ - msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \ - if(tmp == NULL) { goto _failed; } \ - ctx->stack = stack = tmp; \ - ctx->stack_size = stack_size = stack_size * 2; \ - } \ - } \ - */ \ - goto _header_again + if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \ + if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \ + if((count_) == 0) { obj = stack[top].obj; goto _push; } \ + stack[top].ct = ct_; \ + stack[top].count = count_; \ + ++top; \ + /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \ + /*printf("stack push %d\n", top);*/ \ + /* FIXME \ + if(top >= stack_size) { \ + if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \ + size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \ + size_t nsize = csize * 2; \ + msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \ + if(tmp == NULL) { goto _failed; } \ + memcpy(tmp, ctx->stack, csize); \ + ctx->stack = stack = tmp; \ + ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \ + } else { \ + size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \ + msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \ + if(tmp == NULL) { goto _failed; } \ + ctx->stack = stack = tmp; \ + ctx->stack_size = stack_size = stack_size * 2; \ + } \ + } \ + */ \ + goto _header_again #define NEXT_CS(p) \ - ((unsigned int)*p & 0x1f) + ((unsigned int)*p & 0x1f) #ifdef USE_CASE_RANGE #define SWITCH_RANGE_BEGIN switch(*p) { @@ -182,271 +182,271 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c #define SWITCH_RANGE_END } } #endif - if(p == pe) { goto _out; } - do { - switch(cs) { - case CS_HEADER: - SWITCH_RANGE_BEGIN - SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum - push_fixed_value(_uint8, *(uint8_t*)p); - SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum - push_fixed_value(_int8, *(int8_t*)p); - SWITCH_RANGE(0xc0, 0xdf) // Variable - switch(*p) { - case 0xc0: // nil - push_simple_value(_nil); - //case 0xc1: // string - // again_terminal_trail(NEXT_CS(p), p+1); - case 0xc2: // false - push_simple_value(_false); - case 0xc3: // true - push_simple_value(_true); - case 0xc4: // bin 8 - case 0xc5: // bin 16 - case 0xc6: // bin 32 - again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - //case 0xc7: - //case 0xc8: - //case 0xc9: - case 0xca: // float - case 0xcb: // double - case 0xcc: // unsigned int 8 - case 0xcd: // unsigned int 16 - case 0xce: // unsigned int 32 - case 0xcf: // unsigned int 64 - case 0xd0: // signed int 8 - case 0xd1: // signed int 16 - case 0xd2: // signed int 32 - case 0xd3: // signed int 64 - again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - //case 0xd4: - //case 0xd5: - //case 0xd6: // big integer 16 - //case 0xd7: // big integer 32 - //case 0xd8: // big float 16 - case 0xd9: // str 8 - case 0xda: // str 16 - case 0xdb: // str 32 - again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); - case 0xdc: // array 16 - case 0xdd: // array 32 - case 0xde: // map 16 - case 0xdf: // map 32 - again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); - default: - goto _failed; - } - SWITCH_RANGE(0xa0, 0xbf) // FixStr - again_fixed_trail_if_zero(ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); - SWITCH_RANGE(0x90, 0x9f) // FixArray - start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM); - SWITCH_RANGE(0x80, 0x8f) // FixMap - start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY); + if(p == pe) { goto _out; } + do { + switch(cs) { + case CS_HEADER: + SWITCH_RANGE_BEGIN + SWITCH_RANGE(0x00, 0x7f) // Positive Fixnum + push_fixed_value(_uint8, *(uint8_t*)p); + SWITCH_RANGE(0xe0, 0xff) // Negative Fixnum + push_fixed_value(_int8, *(int8_t*)p); + SWITCH_RANGE(0xc0, 0xdf) // Variable + switch(*p) { + case 0xc0: // nil + push_simple_value(_nil); + //case 0xc1: // string + // again_terminal_trail(NEXT_CS(p), p+1); + case 0xc2: // false + push_simple_value(_false); + case 0xc3: // true + push_simple_value(_true); + case 0xc4: // bin 8 + case 0xc5: // bin 16 + case 0xc6: // bin 32 + again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); + //case 0xc7: + //case 0xc8: + //case 0xc9: + case 0xca: // float + case 0xcb: // double + case 0xcc: // unsigned int 8 + case 0xcd: // unsigned int 16 + case 0xce: // unsigned int 32 + case 0xcf: // unsigned int 64 + case 0xd0: // signed int 8 + case 0xd1: // signed int 16 + case 0xd2: // signed int 32 + case 0xd3: // signed int 64 + again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); + //case 0xd4: + //case 0xd5: + //case 0xd6: // big integer 16 + //case 0xd7: // big integer 32 + //case 0xd8: // big float 16 + case 0xd9: // str 8 + case 0xda: // str 16 + case 0xdb: // str 32 + again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) & 0x03) - 1)); + case 0xdc: // array 16 + case 0xdd: // array 32 + case 0xde: // map 16 + case 0xdf: // map 32 + again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); + default: + goto _failed; + } + SWITCH_RANGE(0xa0, 0xbf) // FixStr + again_fixed_trail_if_zero(ACS_STR_VALUE, ((unsigned int)*p & 0x1f), _str_zero); + SWITCH_RANGE(0x90, 0x9f) // FixArray + start_container(_array, ((unsigned int)*p) & 0x0f, CT_ARRAY_ITEM); + SWITCH_RANGE(0x80, 0x8f) // FixMap + start_container(_map, ((unsigned int)*p) & 0x0f, CT_MAP_KEY); - SWITCH_RANGE_DEFAULT - goto _failed; - SWITCH_RANGE_END - // end CS_HEADER + SWITCH_RANGE_DEFAULT + goto _failed; + SWITCH_RANGE_END + // end CS_HEADER - _fixed_trail_again: - ++p; + _fixed_trail_again: + ++p; - default: - if((size_t)(pe - p) < trail) { goto _out; } - n = p; p += trail - 1; - switch(cs) { - //case CS_ - //case CS_ - case CS_FLOAT: { - union { uint32_t i; float f; } mem; - _msgpack_load32(uint32_t, n, &mem.i); - push_fixed_value(_float, mem.f); } - case CS_DOUBLE: { - union { uint64_t i; double f; } mem; - _msgpack_load64(uint64_t, n, &mem.i); + default: + if((size_t)(pe - p) < trail) { goto _out; } + n = p; p += trail - 1; + switch(cs) { + //case CS_ + //case CS_ + case CS_FLOAT: { + union { uint32_t i; float f; } mem; + _msgpack_load32(uint32_t, n, &mem.i); + push_fixed_value(_float, mem.f); } + case CS_DOUBLE: { + union { uint64_t i; double f; } mem; + _msgpack_load64(uint64_t, n, &mem.i); #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif - push_fixed_value(_double, mem.f); } - case CS_UINT_8: - push_fixed_value(_uint8, *(uint8_t*)n); - case CS_UINT_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - push_fixed_value(_uint16, tmp); - } - case CS_UINT_32:{ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - push_fixed_value(_uint32, tmp); - } - case CS_UINT_64:{ - uint64_t tmp; - _msgpack_load64(uint64_t,n,&tmp); - push_fixed_value(_uint64, tmp); - } - case CS_INT_8: - push_fixed_value(_int8, *(int8_t*)n); - case CS_INT_16:{ - int16_t tmp; - _msgpack_load16(int16_t,n,&tmp); - push_fixed_value(_int16, tmp); - } - case CS_INT_32:{ - int32_t tmp; - _msgpack_load32(int32_t,n,&tmp); - push_fixed_value(_int32, tmp); - } - case CS_INT_64:{ - int64_t tmp; - _msgpack_load64(int64_t,n,&tmp); - push_fixed_value(_int64, tmp); - } + push_fixed_value(_double, mem.f); } + case CS_UINT_8: + push_fixed_value(_uint8, *(uint8_t*)n); + case CS_UINT_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + push_fixed_value(_uint16, tmp); + } + case CS_UINT_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + push_fixed_value(_uint32, tmp); + } + case CS_UINT_64:{ + uint64_t tmp; + _msgpack_load64(uint64_t,n,&tmp); + push_fixed_value(_uint64, tmp); + } + case CS_INT_8: + push_fixed_value(_int8, *(int8_t*)n); + case CS_INT_16:{ + int16_t tmp; + _msgpack_load16(int16_t,n,&tmp); + push_fixed_value(_int16, tmp); + } + case CS_INT_32:{ + int32_t tmp; + _msgpack_load32(int32_t,n,&tmp); + push_fixed_value(_int32, tmp); + } + case CS_INT_64:{ + int64_t tmp; + _msgpack_load64(int64_t,n,&tmp); + push_fixed_value(_int64, tmp); + } - //case CS_ - //case CS_ - //case CS_BIG_INT_16: - // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load16(uint16_t,n), _big_int_zero); - //case CS_BIG_INT_32: - // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load32(uint32_t,n), _big_int_zero); - //case ACS_BIG_INT_VALUE: - //_big_int_zero: - // // FIXME - // push_variable_value(_big_int, data, n, trail); + //case CS_ + //case CS_ + //case CS_BIG_INT_16: + // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load16(uint16_t,n), _big_int_zero); + //case CS_BIG_INT_32: + // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load32(uint32_t,n), _big_int_zero); + //case ACS_BIG_INT_VALUE: + //_big_int_zero: + // // FIXME + // push_variable_value(_big_int, data, n, trail); - //case CS_BIG_FLOAT_16: - // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load16(uint16_t,n), _big_float_zero); - //case CS_BIG_FLOAT_32: - // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load32(uint32_t,n), _big_float_zero); - //case ACS_BIG_FLOAT_VALUE: - //_big_float_zero: - // // FIXME - // push_variable_value(_big_float, data, n, trail); + //case CS_BIG_FLOAT_16: + // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load16(uint16_t,n), _big_float_zero); + //case CS_BIG_FLOAT_32: + // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load32(uint32_t,n), _big_float_zero); + //case ACS_BIG_FLOAT_VALUE: + //_big_float_zero: + // // FIXME + // push_variable_value(_big_float, data, n, trail); - case CS_STR_8: - again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero); - case CS_BIN_8: - again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); - case CS_STR_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); - } - case CS_BIN_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); - } - case CS_STR_32:{ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); - } - case CS_BIN_32:{ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); - } - case ACS_STR_VALUE: - _str_zero: - push_variable_value(_str, data, n, trail); - case ACS_BIN_VALUE: - _bin_zero: - push_variable_value(_bin, data, n, trail); + case CS_STR_8: + again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero); + case CS_BIN_8: + again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); + case CS_STR_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); + } + case CS_BIN_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); + } + case CS_STR_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_STR_VALUE, tmp, _str_zero); + } + case CS_BIN_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); + } + case ACS_STR_VALUE: + _str_zero: + push_variable_value(_str, data, n, trail); + case ACS_BIN_VALUE: + _bin_zero: + push_variable_value(_bin, data, n, trail); - case CS_ARRAY_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - start_container(_array, tmp, CT_ARRAY_ITEM); - } - case CS_ARRAY_32:{ - /* FIXME security guard */ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - start_container(_array, tmp, CT_ARRAY_ITEM); - } + case CS_ARRAY_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + start_container(_array, tmp, CT_ARRAY_ITEM); + } + case CS_ARRAY_32:{ + /* FIXME security guard */ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + start_container(_array, tmp, CT_ARRAY_ITEM); + } - case CS_MAP_16:{ - uint16_t tmp; - _msgpack_load16(uint16_t,n,&tmp); - start_container(_map, tmp, CT_MAP_KEY); - } - case CS_MAP_32:{ - /* FIXME security guard */ - uint32_t tmp; - _msgpack_load32(uint32_t,n,&tmp); - start_container(_map, tmp, CT_MAP_KEY); - } + case CS_MAP_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + start_container(_map, tmp, CT_MAP_KEY); + } + case CS_MAP_32:{ + /* FIXME security guard */ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + start_container(_map, tmp, CT_MAP_KEY); + } - default: - goto _failed; - } - } + default: + goto _failed; + } + } _push: - if(top == 0) { goto _finish; } - c = &stack[top-1]; - switch(c->ct) { - case CT_ARRAY_ITEM: - if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - goto _header_again; - case CT_MAP_KEY: - c->map_key = obj; - c->ct = CT_MAP_VALUE; - goto _header_again; - case CT_MAP_VALUE: - if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; } - if(--c->count == 0) { - obj = c->obj; - --top; - /*printf("stack pop %d\n", top);*/ - goto _push; - } - c->ct = CT_MAP_KEY; - goto _header_again; + if(top == 0) { goto _finish; } + c = &stack[top-1]; + switch(c->ct) { + case CT_ARRAY_ITEM: + if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; } + if(--c->count == 0) { + obj = c->obj; + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } + goto _header_again; + case CT_MAP_KEY: + c->map_key = obj; + c->ct = CT_MAP_VALUE; + goto _header_again; + case CT_MAP_VALUE: + if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; } + if(--c->count == 0) { + obj = c->obj; + --top; + /*printf("stack pop %d\n", top);*/ + goto _push; + } + c->ct = CT_MAP_KEY; + goto _header_again; - default: - goto _failed; - } + default: + goto _failed; + } _header_again: - cs = CS_HEADER; - ++p; - } while(p != pe); - goto _out; + cs = CS_HEADER; + ++p; + } while(p != pe); + goto _out; _finish: - stack[0].obj = obj; - ++p; - ret = 1; - /*printf("-- finish --\n"); */ - goto _end; + stack[0].obj = obj; + ++p; + ret = 1; + /*printf("-- finish --\n"); */ + goto _end; _failed: - /*printf("** FAILED **\n"); */ - ret = -1; - goto _end; + /*printf("** FAILED **\n"); */ + ret = -1; + goto _end; _out: - ret = 0; - goto _end; + ret = 0; + goto _end; _end: - ctx->cs = cs; - ctx->trail = trail; - ctx->top = top; - *off = (size_t)(p - (const unsigned char*)data); + ctx->cs = cs; + ctx->trail = trail; + ctx->top = top; + *off = (size_t)(p - (const unsigned char*)data); - return ret; + return ret; } diff --git a/include/msgpack/version.hpp b/include/msgpack/version.hpp index 48f59360..d9e2f371 100644 --- a/include/msgpack/version.hpp +++ b/include/msgpack/version.hpp @@ -26,15 +26,15 @@ #define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_RELEASE) inline const char* msgpack_version(void) { - return MSGPACK_VERSION; + return MSGPACK_VERSION; } inline int msgpack_version_major(void) { - return MSGPACK_VERSION_MAJOR; + return MSGPACK_VERSION_MAJOR; } inline int msgpack_version_minor(void) { - return MSGPACK_VERSION_MINOR; + return MSGPACK_VERSION_MINOR; } #endif /* msgpack/version.hpp */ diff --git a/include/msgpack/vrefbuffer.h b/include/msgpack/vrefbuffer.h index cc912b35..e16e9051 100644 --- a/include/msgpack/vrefbuffer.h +++ b/include/msgpack/vrefbuffer.h @@ -25,8 +25,8 @@ #include #else struct iovec { - void *iov_base; - size_t iov_len; + void *iov_base; + size_t iov_len; }; #endif @@ -45,20 +45,20 @@ struct msgpack_vrefbuffer_chunk; typedef struct msgpack_vrefbuffer_chunk msgpack_vrefbuffer_chunk; typedef struct msgpack_vrefbuffer_inner_buffer { - size_t free; - char* ptr; - msgpack_vrefbuffer_chunk* head; + size_t free; + char* ptr; + msgpack_vrefbuffer_chunk* head; } msgpack_vrefbuffer_inner_buffer; typedef struct msgpack_vrefbuffer { - struct iovec* tail; - struct iovec* end; - struct iovec* array; + struct iovec* tail; + struct iovec* end; + struct iovec* array; - size_t chunk_size; - size_t ref_size; + size_t chunk_size; + size_t ref_size; - msgpack_vrefbuffer_inner_buffer inner_buffer; + msgpack_vrefbuffer_inner_buffer inner_buffer; } msgpack_vrefbuffer; @@ -71,7 +71,7 @@ typedef struct msgpack_vrefbuffer { #endif bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, - size_t ref_size, size_t chunk_size); + size_t ref_size, size_t chunk_size); void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf); static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size); @@ -83,10 +83,10 @@ static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffe static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref); int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len); + const char* buf, size_t len); int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len); + const char* buf, size_t len); int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to); @@ -97,41 +97,41 @@ void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vref); static inline msgpack_vrefbuffer* msgpack_vrefbuffer_new(size_t ref_size, size_t chunk_size) { - msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer)); - if (vbuf == NULL) return NULL; - if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) { - free(vbuf); - return NULL; - } - return vbuf; + msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)malloc(sizeof(msgpack_vrefbuffer)); + if (vbuf == NULL) return NULL; + if(!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) { + free(vbuf); + return NULL; + } + return vbuf; } static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf) { - if(vbuf == NULL) { return; } - msgpack_vrefbuffer_destroy(vbuf); - free(vbuf); + if(vbuf == NULL) { return; } + msgpack_vrefbuffer_destroy(vbuf); + free(vbuf); } static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len) { - msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data; + msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data; - if(len < vbuf->ref_size) { - return msgpack_vrefbuffer_append_copy(vbuf, buf, len); - } else { - return msgpack_vrefbuffer_append_ref(vbuf, buf, len); - } + if(len < vbuf->ref_size) { + return msgpack_vrefbuffer_append_copy(vbuf, buf, len); + } else { + return msgpack_vrefbuffer_append_ref(vbuf, buf, len); + } } static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref) { - return vref->array; + return vref->array; } static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref) { - return (size_t)(vref->tail - vref->array); + return (size_t)(vref->tail - vref->array); } diff --git a/include/msgpack/vrefbuffer.hpp b/include/msgpack/vrefbuffer.hpp index 575bbed4..c8ac49af 100644 --- a/include/msgpack/vrefbuffer.hpp +++ b/include/msgpack/vrefbuffer.hpp @@ -32,8 +32,8 @@ #include #else struct iovec { - void *iov_base; - size_t iov_len; + void *iov_base; + size_t iov_len; }; #endif @@ -46,230 +46,230 @@ namespace detail { class vrefbuffer { private: - struct chunk { - chunk* next; - }; - struct inner_buffer { - size_t free; - char* ptr; - chunk* head; - }; + struct chunk { + chunk* next; + }; + struct inner_buffer { + size_t free; + char* ptr; + chunk* head; + }; public: - vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, - size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) - :m_ref_size(ref_size), m_chunk_size(chunk_size) - { - size_t nfirst = (sizeof(iovec) < 72/2) ? - 72 / sizeof(iovec) : 8; + vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, + size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) + :m_ref_size(ref_size), m_chunk_size(chunk_size) + { + size_t nfirst = (sizeof(iovec) < 72/2) ? + 72 / sizeof(iovec) : 8; - iovec* array = static_cast(::malloc( - sizeof(iovec) * nfirst)); - if(!array) { - throw std::bad_alloc(); - } + iovec* array = static_cast(::malloc( + sizeof(iovec) * nfirst)); + if(!array) { + throw std::bad_alloc(); + } - m_tail = array; - m_end = array + nfirst; - m_array = array; + m_tail = array; + m_end = array + nfirst; + m_array = array; - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - ::free(array); - throw std::bad_alloc(); - } - inner_buffer* const ib = &m_inner_buffer; + chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); + if(!c) { + ::free(array); + throw std::bad_alloc(); + } + inner_buffer* const ib = &m_inner_buffer; - ib->free = chunk_size; - ib->ptr = reinterpret_cast(c) + sizeof(chunk); - ib->head = c; - c->next = nullptr; + ib->free = chunk_size; + ib->ptr = reinterpret_cast(c) + sizeof(chunk); + ib->head = c; + c->next = nullptr; - } + } - ~vrefbuffer() - { - chunk* c = m_inner_buffer.head; - while(true) { - chunk* n = c->next; - ::free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } - ::free(m_array); - } + ~vrefbuffer() + { + chunk* c = m_inner_buffer.head; + while(true) { + chunk* n = c->next; + ::free(c); + if(n != NULL) { + c = n; + } else { + break; + } + } + ::free(m_array); + } public: - void write(const char* buf, size_t len) - { - if(len < m_ref_size) { - append_copy(buf, len); - } else { - append_ref(buf, len); - } - } + void write(const char* buf, size_t len) + { + if(len < m_ref_size) { + append_copy(buf, len); + } else { + append_ref(buf, len); + } + } - void append_ref(const char* buf, size_t len) - { - if(m_tail == m_end) { - const size_t nused = m_tail - m_array; - const size_t nnext = nused * 2; + void append_ref(const char* buf, size_t len) + { + if(m_tail == m_end) { + const size_t nused = m_tail - m_array; + const size_t nnext = nused * 2; - iovec* nvec = static_cast(::realloc( - m_array, sizeof(iovec)*nnext)); - if(!nvec) { - throw std::bad_alloc(); - } + iovec* nvec = static_cast(::realloc( + m_array, sizeof(iovec)*nnext)); + if(!nvec) { + throw std::bad_alloc(); + } - m_array = nvec; - m_end = nvec + nnext; - m_tail = nvec + nused; - } + m_array = nvec; + m_end = nvec + nnext; + m_tail = nvec + nused; + } - m_tail->iov_base = const_cast(buf); - m_tail->iov_len = len; - ++m_tail; - } + m_tail->iov_base = const_cast(buf); + m_tail->iov_len = len; + ++m_tail; + } - void append_copy(const char* buf, size_t len) - { - inner_buffer* const ib = &m_inner_buffer; + void append_copy(const char* buf, size_t len) + { + inner_buffer* const ib = &m_inner_buffer; - if(ib->free < len) { - size_t sz = m_chunk_size; - if(sz < len) { - sz = len; - } + if(ib->free < len) { + size_t sz = m_chunk_size; + if(sz < len) { + sz = len; + } - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - if(!c) { - throw std::bad_alloc(); - } + chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if(!c) { + throw std::bad_alloc(); + } - c->next = ib->head; - ib->head = c; - ib->free = sz; - ib->ptr = reinterpret_cast(c) + sizeof(chunk); - } + c->next = ib->head; + ib->head = c; + ib->free = sz; + ib->ptr = reinterpret_cast(c) + sizeof(chunk); + } - char* m = ib->ptr; - ::memcpy(m, buf, len); - ib->free -= len; - ib->ptr += len; + char* m = ib->ptr; + ::memcpy(m, buf, len); + ib->free -= len; + ib->ptr += len; - if(m_tail != m_array && m == - static_cast( - const_cast((m_tail - 1)->iov_base) - ) + (m_tail - 1)->iov_len) { - (m_tail - 1)->iov_len += len; - return; - } else { - append_ref( m, len); - } - } + if(m_tail != m_array && m == + static_cast( + const_cast((m_tail - 1)->iov_base) + ) + (m_tail - 1)->iov_len) { + (m_tail - 1)->iov_len += len; + return; + } else { + append_ref( m, len); + } + } - const struct iovec* vector() const - { - return m_array; - } + const struct iovec* vector() const + { + return m_array; + } - size_t vector_size() const - { - return m_tail - m_array; - } + size_t vector_size() const + { + return m_tail - m_array; + } - void migrate(vrefbuffer* to) - { - size_t sz = m_chunk_size; + void migrate(vrefbuffer* to) + { + size_t sz = m_chunk_size; - chunk* empty = static_cast(::malloc(sizeof(chunk) + sz)); - if(!empty) { - throw std::bad_alloc(); - } + chunk* empty = static_cast(::malloc(sizeof(chunk) + sz)); + if(!empty) { + throw std::bad_alloc(); + } - empty->next = nullptr; + empty->next = nullptr; - const size_t nused = m_tail - m_array; - if(to->m_tail + nused < m_end) { - const size_t tosize = to->m_tail - to->m_array; - const size_t reqsize = nused + tosize; - size_t nnext = (to->m_end - to->m_array) * 2; - while(nnext < reqsize) { - nnext *= 2; - } + const size_t nused = m_tail - m_array; + if(to->m_tail + nused < m_end) { + const size_t tosize = to->m_tail - to->m_array; + const size_t reqsize = nused + tosize; + size_t nnext = (to->m_end - to->m_array) * 2; + while(nnext < reqsize) { + nnext *= 2; + } - iovec* nvec = static_cast(::realloc( - to->m_array, sizeof(iovec)*nnext)); - if(!nvec) { - ::free(empty); - throw std::bad_alloc(); - } + iovec* nvec = static_cast(::realloc( + to->m_array, sizeof(iovec)*nnext)); + if(!nvec) { + ::free(empty); + throw std::bad_alloc(); + } - to->m_array = nvec; - to->m_end = nvec + nnext; - to->m_tail = nvec + tosize; - } + to->m_array = nvec; + to->m_end = nvec + nnext; + to->m_tail = nvec + tosize; + } - ::memcpy(to->m_tail, m_array, sizeof(iovec)*nused); + ::memcpy(to->m_tail, m_array, sizeof(iovec)*nused); - to->m_tail += nused; - m_tail = m_array; + to->m_tail += nused; + m_tail = m_array; - inner_buffer* const ib = &m_inner_buffer; - inner_buffer* const toib = &to->m_inner_buffer; + inner_buffer* const ib = &m_inner_buffer; + inner_buffer* const toib = &to->m_inner_buffer; - chunk* last = ib->head; - while(last->next) { - last = last->next; - } - last->next = toib->head; - toib->head = ib->head; + chunk* last = ib->head; + while(last->next) { + last = last->next; + } + last->next = toib->head; + toib->head = ib->head; - if(toib->free < ib->free) { - toib->free = ib->free; - toib->ptr = ib->ptr; - } + if(toib->free < ib->free) { + toib->free = ib->free; + toib->ptr = ib->ptr; + } - ib->head = empty; - ib->free = sz; - ib->ptr = reinterpret_cast(empty) + sizeof(chunk); + ib->head = empty; + ib->free = sz; + ib->ptr = reinterpret_cast(empty) + sizeof(chunk); - } + } - void clear() - { - chunk* c = m_inner_buffer.head->next; - chunk* n; - while(c) { - n = c->next; - ::free(c); - c = n; - } + void clear() + { + chunk* c = m_inner_buffer.head->next; + chunk* n; + while(c) { + n = c->next; + ::free(c); + c = n; + } - inner_buffer* const ib = &m_inner_buffer; - c = ib->head; - c->next = nullptr; - ib->free = m_chunk_size; - ib->ptr = reinterpret_cast(c) + sizeof(chunk); + inner_buffer* const ib = &m_inner_buffer; + c = ib->head; + c->next = nullptr; + ib->free = m_chunk_size; + ib->ptr = reinterpret_cast(c) + sizeof(chunk); - m_tail = m_array; - } + m_tail = m_array; + } private: - vrefbuffer(const vrefbuffer&); + vrefbuffer(const vrefbuffer&); private: - iovec* m_tail; - iovec* m_end; - iovec* m_array; + iovec* m_tail; + iovec* m_end; + iovec* m_array; - size_t m_ref_size; - size_t m_chunk_size; + size_t m_ref_size; + size_t m_chunk_size; - inner_buffer m_inner_buffer; + inner_buffer m_inner_buffer; }; diff --git a/include/msgpack/zbuffer.h b/include/msgpack/zbuffer.h index d7f65ce9..dbad72c5 100644 --- a/include/msgpack/zbuffer.h +++ b/include/msgpack/zbuffer.h @@ -35,17 +35,17 @@ extern "C" { */ typedef struct msgpack_zbuffer { - z_stream stream; - char* data; - size_t init_size; + z_stream stream; + char* data; + size_t init_size; } msgpack_zbuffer; #ifndef MSGPACK_ZBUFFER_INIT_SIZE #define MSGPACK_ZBUFFER_INIT_SIZE 8192 #endif -static inline bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, - int level, size_t init_size); +static inline bool msgpack_zbuffer_init( + msgpack_zbuffer* zbuf, int level, size_t init_size); static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf); static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size); @@ -71,130 +71,130 @@ static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf); bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, - int level, size_t init_size) + int level, size_t init_size) { - memset(zbuf, 0, sizeof(msgpack_zbuffer)); - zbuf->init_size = init_size; - if(deflateInit(&zbuf->stream, level) != Z_OK) { - free(zbuf->data); - return false; - } - return true; + memset(zbuf, 0, sizeof(msgpack_zbuffer)); + zbuf->init_size = init_size; + if(deflateInit(&zbuf->stream, level) != Z_OK) { + free(zbuf->data); + return false; + } + return true; } void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf) { - deflateEnd(&zbuf->stream); - free(zbuf->data); + deflateEnd(&zbuf->stream); + free(zbuf->data); } msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size) { - msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer)); - if (zbuf == NULL) return NULL; - if(!msgpack_zbuffer_init(zbuf, level, init_size)) { - free(zbuf); - return NULL; - } - return zbuf; + msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer)); + if (zbuf == NULL) return NULL; + if(!msgpack_zbuffer_init(zbuf, level, init_size)) { + free(zbuf); + return NULL; + } + return zbuf; } void msgpack_zbuffer_free(msgpack_zbuffer* zbuf) { - if(zbuf == NULL) { return; } - msgpack_zbuffer_destroy(zbuf); - free(zbuf); + if(zbuf == NULL) { return; } + msgpack_zbuffer_destroy(zbuf); + free(zbuf); } bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf) { - size_t used = (char*)zbuf->stream.next_out - zbuf->data; - size_t csize = used + zbuf->stream.avail_out; - size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2; + size_t used = (char*)zbuf->stream.next_out - zbuf->data; + size_t csize = used + zbuf->stream.avail_out; + size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2; - char* tmp = (char*)realloc(zbuf->data, nsize); - if(tmp == NULL) { - return false; - } + char* tmp = (char*)realloc(zbuf->data, nsize); + if(tmp == NULL) { + return false; + } - zbuf->data = tmp; - zbuf->stream.next_out = (Bytef*)(tmp + used); - zbuf->stream.avail_out = nsize - used; + zbuf->data = tmp; + zbuf->stream.next_out = (Bytef*)(tmp + used); + zbuf->stream.avail_out = nsize - used; - return true; + return true; } int msgpack_zbuffer_write(void* data, const char* buf, size_t len) { - msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data; + msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data; - zbuf->stream.next_in = (Bytef*)buf; - zbuf->stream.avail_in = len; + zbuf->stream.next_in = (Bytef*)buf; + zbuf->stream.avail_in = len; - do { - if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { - if(!msgpack_zbuffer_expand(zbuf)) { - return -1; - } - } + do { + if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { + if(!msgpack_zbuffer_expand(zbuf)) { + return -1; + } + } - if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) { - return -1; - } - } while(zbuf->stream.avail_in > 0); + if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) { + return -1; + } + } while(zbuf->stream.avail_in > 0); - return 0; + return 0; } char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf) { - while(true) { - switch(deflate(&zbuf->stream, Z_FINISH)) { - case Z_STREAM_END: - return zbuf->data; - case Z_OK: - if(!msgpack_zbuffer_expand(zbuf)) { - return NULL; - } - break; - default: - return NULL; - } - } + while(true) { + switch(deflate(&zbuf->stream, Z_FINISH)) { + case Z_STREAM_END: + return zbuf->data; + case Z_OK: + if(!msgpack_zbuffer_expand(zbuf)) { + return NULL; + } + break; + default: + return NULL; + } + } } const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf) { - return zbuf->data; + return zbuf->data; } size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf) { - return (char*)zbuf->stream.next_out - zbuf->data; + return (char*)zbuf->stream.next_out - zbuf->data; } void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf) { - zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data; - zbuf->stream.next_out = (Bytef*)zbuf->data; + zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data; + zbuf->stream.next_out = (Bytef*)zbuf->data; } bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf) { - if(deflateReset(&zbuf->stream) != Z_OK) { - return false; - } - msgpack_zbuffer_reset_buffer(zbuf); - return true; + if(deflateReset(&zbuf->stream) != Z_OK) { + return false; + } + msgpack_zbuffer_reset_buffer(zbuf); + return true; } char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf) { - char* tmp = zbuf->data; - zbuf->data = NULL; - zbuf->stream.next_out = NULL; - zbuf->stream.avail_out = 0; - return tmp; + char* tmp = zbuf->data; + zbuf->data = NULL; + zbuf->stream.next_out = NULL; + zbuf->stream.avail_out = 0; + return tmp; } /** @} */ diff --git a/include/msgpack/zbuffer.hpp b/include/msgpack/zbuffer.hpp index 5606d372..6dd72341 100644 --- a/include/msgpack/zbuffer.hpp +++ b/include/msgpack/zbuffer.hpp @@ -34,125 +34,125 @@ namespace msgpack { class zbuffer { public: - zbuffer(int level = Z_DEFAULT_COMPRESSION, - size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE) - : m_data(nullptr), m_init_size(init_size) - { - m_stream.zalloc = Z_NULL; - m_stream.zfree = Z_NULL; - m_stream.opaque = Z_NULL; - m_stream.next_out = Z_NULL; - m_stream.avail_out = 0; - if(deflateInit(&m_stream, level) != Z_OK) { - throw std::bad_alloc(); - } - } + zbuffer(int level = Z_DEFAULT_COMPRESSION, + size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE) + : m_data(nullptr), m_init_size(init_size) + { + m_stream.zalloc = Z_NULL; + m_stream.zfree = Z_NULL; + m_stream.opaque = Z_NULL; + m_stream.next_out = Z_NULL; + m_stream.avail_out = 0; + if(deflateInit(&m_stream, level) != Z_OK) { + throw std::bad_alloc(); + } + } - ~zbuffer() - { - deflateEnd(&m_stream); - ::free(m_data); - } + ~zbuffer() + { + deflateEnd(&m_stream); + ::free(m_data); + } public: - void write(const char* buf, size_t len) - { - m_stream.next_in = reinterpret_cast(const_cast(buf)); - m_stream.avail_in = len; + void write(const char* buf, size_t len) + { + m_stream.next_in = reinterpret_cast(const_cast(buf)); + m_stream.avail_in = len; - do { - if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { - if(!expand()) { - throw std::bad_alloc(); - } - } + do { + if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { + if(!expand()) { + throw std::bad_alloc(); + } + } - if(deflate(&m_stream, Z_NO_FLUSH) != Z_OK) { - throw std::bad_alloc(); - } - } while(m_stream.avail_in > 0); - } + if(deflate(&m_stream, Z_NO_FLUSH) != Z_OK) { + throw std::bad_alloc(); + } + } while(m_stream.avail_in > 0); + } - char* flush() - { - while(true) { - switch(deflate(&m_stream, Z_FINISH)) { - case Z_STREAM_END: - return m_data; - case Z_OK: - if(!expand()) { - throw std::bad_alloc(); - } - break; - default: - throw std::bad_alloc(); - } - } - } + char* flush() + { + while(true) { + switch(deflate(&m_stream, Z_FINISH)) { + case Z_STREAM_END: + return m_data; + case Z_OK: + if(!expand()) { + throw std::bad_alloc(); + } + break; + default: + throw std::bad_alloc(); + } + } + } - char* data() - { - return m_data; - } + char* data() + { + return m_data; + } - const char* data() const - { - return m_data; - } + const char* data() const + { + return m_data; + } - size_t size() const - { - return reinterpret_cast(m_stream.next_out) - m_data; - } + size_t size() const + { + return reinterpret_cast(m_stream.next_out) - m_data; + } - void reset() - { - if(deflateReset(&m_stream) != Z_OK) { - throw std::bad_alloc(); - } - reset_buffer(); - } + void reset() + { + if(deflateReset(&m_stream) != Z_OK) { + throw std::bad_alloc(); + } + reset_buffer(); + } - void reset_buffer() - { - m_stream.avail_out += reinterpret_cast(m_stream.next_out) - m_data; - m_stream.next_out = reinterpret_cast(m_data); - } + void reset_buffer() + { + m_stream.avail_out += reinterpret_cast(m_stream.next_out) - m_data; + m_stream.next_out = reinterpret_cast(m_data); + } - char* release_buffer() - { - char* tmp = m_data; - m_data = nullptr; - m_stream.next_out = nullptr; - m_stream.avail_out = 0; - return tmp; - } + char* release_buffer() + { + char* tmp = m_data; + m_data = nullptr; + m_stream.next_out = nullptr; + m_stream.avail_out = 0; + return tmp; + } private: - bool expand() - { - size_t used = reinterpret_cast(m_stream.next_out) - m_data; - size_t csize = used + m_stream.avail_out; - size_t nsize = (csize == 0) ? m_init_size : csize * 2; + bool expand() + { + size_t used = reinterpret_cast(m_stream.next_out) - m_data; + size_t csize = used + m_stream.avail_out; + size_t nsize = (csize == 0) ? m_init_size : csize * 2; - char* tmp = static_cast(::realloc(m_data, nsize)); - if(tmp == nullptr) { - return false; - } + char* tmp = static_cast(::realloc(m_data, nsize)); + if(tmp == nullptr) { + return false; + } - m_data = tmp; - m_stream.next_out = reinterpret_cast(tmp + used); - m_stream.avail_out = nsize - used; + m_data = tmp; + m_stream.next_out = reinterpret_cast(tmp + used); + m_stream.avail_out = nsize - used; - return true; - } + return true; + } private: - zbuffer(const zbuffer&); + zbuffer(const zbuffer&); private: - z_stream m_stream; - char* m_data; - size_t m_init_size; + z_stream m_stream; + char* m_data; + size_t m_init_size; }; diff --git a/include/msgpack/zone.h b/include/msgpack/zone.h index 1f68a3c4..177750af 100644 --- a/include/msgpack/zone.h +++ b/include/msgpack/zone.h @@ -32,29 +32,29 @@ extern "C" { */ typedef struct msgpack_zone_finalizer { - void (*func)(void* data); - void* data; + void (*func)(void* data); + void* data; } msgpack_zone_finalizer; typedef struct msgpack_zone_finalizer_array { - msgpack_zone_finalizer* tail; - msgpack_zone_finalizer* end; - msgpack_zone_finalizer* array; + msgpack_zone_finalizer* tail; + msgpack_zone_finalizer* end; + msgpack_zone_finalizer* array; } msgpack_zone_finalizer_array; struct msgpack_zone_chunk; typedef struct msgpack_zone_chunk msgpack_zone_chunk; typedef struct msgpack_zone_chunk_list { - size_t free; - char* ptr; - msgpack_zone_chunk* head; + size_t free; + char* ptr; + msgpack_zone_chunk* head; } msgpack_zone_chunk_list; typedef struct msgpack_zone { - msgpack_zone_chunk_list chunk_list; - msgpack_zone_finalizer_array finalizer_array; - size_t chunk_size; + msgpack_zone_chunk_list chunk_list; + msgpack_zone_finalizer_array finalizer_array; + size_t chunk_size; } msgpack_zone; #ifndef MSGPACK_ZONE_CHUNK_SIZE @@ -71,7 +71,7 @@ static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size); static inline void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size); static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone, - void (*func)(void* data), void* data); + void (*func)(void* data), void* data); static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b); @@ -90,53 +90,53 @@ void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size); void* msgpack_zone_malloc_no_align(msgpack_zone* zone, size_t size) { - char* ptr; - msgpack_zone_chunk_list* cl = &zone->chunk_list; + char* ptr; + msgpack_zone_chunk_list* cl = &zone->chunk_list; - if(zone->chunk_list.free < size) { - return msgpack_zone_malloc_expand(zone, size); - } + if(zone->chunk_list.free < size) { + return msgpack_zone_malloc_expand(zone, size); + } - ptr = cl->ptr; - cl->free -= size; - cl->ptr += size; + ptr = cl->ptr; + cl->free -= size; + cl->ptr += size; - return ptr; + return ptr; } static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size) { - return msgpack_zone_malloc_no_align(zone, - ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); + return msgpack_zone_malloc_no_align(zone, + ((size)+((MSGPACK_ZONE_ALIGN)-1)) & ~((MSGPACK_ZONE_ALIGN)-1)); } bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone, - void (*func)(void* data), void* data); + void (*func)(void* data), void* data); static inline bool msgpack_zone_push_finalizer(msgpack_zone* zone, - void (*func)(void* data), void* data) + void (*func)(void* data), void* data) { - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - msgpack_zone_finalizer* fin = fa->tail; + msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; + msgpack_zone_finalizer* fin = fa->tail; - if(fin == fa->end) { - return msgpack_zone_push_finalizer_expand(zone, func, data); - } + if(fin == fa->end) { + return msgpack_zone_push_finalizer_expand(zone, func, data); + } - fin->func = func; - fin->data = data; + fin->func = func; + fin->data = data; - ++fa->tail; + ++fa->tail; - return true; + return true; } static inline void msgpack_zone_swap(msgpack_zone* a, msgpack_zone* b) { - msgpack_zone tmp = *a; - *a = *b; - *b = tmp; + msgpack_zone tmp = *a; + *a = *b; + *b = tmp; } diff --git a/include/msgpack/zone.hpp b/include/msgpack/zone.hpp index c019fb05..9a23af9e 100644 --- a/include/msgpack/zone.hpp +++ b/include/msgpack/zone.hpp @@ -3,17 +3,17 @@ // // Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi // -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at // -// http://www.apache.org/licenses/LICENSE-2.0 +// http://www.apache.org/licenses/LICENSE-2.0 // -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. // #ifndef MSGPACK_ZONE_HPP #define MSGPACK_ZONE_HPP diff --git a/src/gcc_atomic.hpp b/src/gcc_atomic.hpp index 8b5c087e..7e6dc00d 100644 --- a/src/gcc_atomic.hpp +++ b/src/gcc_atomic.hpp @@ -27,12 +27,12 @@ int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) { - return __gnu_cxx::__exchange_and_add(ptr, -1) - 1; + return __gnu_cxx::__exchange_and_add(ptr, -1) - 1; } int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) { - return __gnu_cxx::__exchange_and_add(ptr, 1) + 1; + return __gnu_cxx::__exchange_and_add(ptr, 1) + 1; } #endif // old gcc workaround diff --git a/src/objectc.c b/src/objectc.c index 903f101f..ff5f6882 100644 --- a/src/objectc.c +++ b/src/objectc.c @@ -34,221 +34,221 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d) { - switch(d.type) { - case MSGPACK_OBJECT_NIL: - return msgpack_pack_nil(pk); + switch(d.type) { + case MSGPACK_OBJECT_NIL: + return msgpack_pack_nil(pk); - case MSGPACK_OBJECT_BOOLEAN: - if(d.via.boolean) { - return msgpack_pack_true(pk); - } else { - return msgpack_pack_false(pk); - } + case MSGPACK_OBJECT_BOOLEAN: + if(d.via.boolean) { + return msgpack_pack_true(pk); + } else { + return msgpack_pack_false(pk); + } - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return msgpack_pack_uint64(pk, d.via.u64); + case MSGPACK_OBJECT_POSITIVE_INTEGER: + return msgpack_pack_uint64(pk, d.via.u64); - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return msgpack_pack_int64(pk, d.via.i64); + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + return msgpack_pack_int64(pk, d.via.i64); - case MSGPACK_OBJECT_DOUBLE: - return msgpack_pack_double(pk, d.via.dec); + case MSGPACK_OBJECT_DOUBLE: + return msgpack_pack_double(pk, d.via.dec); - case MSGPACK_OBJECT_STR: - { - int ret = msgpack_pack_str(pk, d.via.str.size); - if(ret < 0) { return ret; } - return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size); - } + case MSGPACK_OBJECT_STR: + { + int ret = msgpack_pack_str(pk, d.via.str.size); + if(ret < 0) { return ret; } + return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size); + } - case MSGPACK_OBJECT_BIN: - { - int ret = msgpack_pack_bin(pk, d.via.bin.size); - if(ret < 0) { return ret; } - return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); - } + case MSGPACK_OBJECT_BIN: + { + int ret = msgpack_pack_bin(pk, d.via.bin.size); + if(ret < 0) { return ret; } + return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); + } - case MSGPACK_OBJECT_ARRAY: - { - int ret = msgpack_pack_array(pk, d.via.array.size); - if(ret < 0) { return ret; } + case MSGPACK_OBJECT_ARRAY: + { + int ret = msgpack_pack_array(pk, d.via.array.size); + if(ret < 0) { return ret; } - msgpack_object* o = d.via.array.ptr; - msgpack_object* const oend = d.via.array.ptr + d.via.array.size; - for(; o != oend; ++o) { - ret = msgpack_pack_object(pk, *o); - if(ret < 0) { return ret; } - } + msgpack_object* o = d.via.array.ptr; + msgpack_object* const oend = d.via.array.ptr + d.via.array.size; + for(; o != oend; ++o) { + ret = msgpack_pack_object(pk, *o); + if(ret < 0) { return ret; } + } - return 0; - } + return 0; + } - case MSGPACK_OBJECT_MAP: - { - int ret = msgpack_pack_map(pk, d.via.map.size); - if(ret < 0) { return ret; } + case MSGPACK_OBJECT_MAP: + { + int ret = msgpack_pack_map(pk, d.via.map.size); + if(ret < 0) { return ret; } - msgpack_object_kv* kv = d.via.map.ptr; - msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size; - for(; kv != kvend; ++kv) { - ret = msgpack_pack_object(pk, kv->key); - if(ret < 0) { return ret; } - ret = msgpack_pack_object(pk, kv->val); - if(ret < 0) { return ret; } - } + msgpack_object_kv* kv = d.via.map.ptr; + msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size; + for(; kv != kvend; ++kv) { + ret = msgpack_pack_object(pk, kv->key); + if(ret < 0) { return ret; } + ret = msgpack_pack_object(pk, kv->val); + if(ret < 0) { return ret; } + } - return 0; - } + return 0; + } - default: - return -1; - } + default: + return -1; + } } void msgpack_object_print(FILE* out, msgpack_object o) { - switch(o.type) { - case MSGPACK_OBJECT_NIL: - fprintf(out, "nil"); - break; + switch(o.type) { + case MSGPACK_OBJECT_NIL: + fprintf(out, "nil"); + break; - case MSGPACK_OBJECT_BOOLEAN: - fprintf(out, (o.via.boolean ? "true" : "false")); - break; + case MSGPACK_OBJECT_BOOLEAN: + fprintf(out, (o.via.boolean ? "true" : "false")); + break; - case MSGPACK_OBJECT_POSITIVE_INTEGER: - fprintf(out, "%" PRIu64, o.via.u64); - break; + case MSGPACK_OBJECT_POSITIVE_INTEGER: + fprintf(out, "%" PRIu64, o.via.u64); + break; - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - fprintf(out, "%" PRIi64, o.via.i64); - break; + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + fprintf(out, "%" PRIi64, o.via.i64); + break; - case MSGPACK_OBJECT_DOUBLE: - fprintf(out, "%f", o.via.dec); - break; + case MSGPACK_OBJECT_DOUBLE: + fprintf(out, "%f", o.via.dec); + break; - case MSGPACK_OBJECT_STR: - fprintf(out, "\""); - fwrite(o.via.str.ptr, o.via.str.size, 1, out); - fprintf(out, "\""); - break; + case MSGPACK_OBJECT_STR: + fprintf(out, "\""); + fwrite(o.via.str.ptr, o.via.str.size, 1, out); + fprintf(out, "\""); + break; - case MSGPACK_OBJECT_BIN: - fprintf(out, "\""); - fwrite(o.via.bin.ptr, o.via.bin.size, 1, out); - fprintf(out, "\""); - break; + case MSGPACK_OBJECT_BIN: + fprintf(out, "\""); + fwrite(o.via.bin.ptr, o.via.bin.size, 1, out); + fprintf(out, "\""); + break; - case MSGPACK_OBJECT_ARRAY: - fprintf(out, "["); - if(o.via.array.size != 0) { - msgpack_object* p = o.via.array.ptr; - msgpack_object_print(out, *p); - ++p; - msgpack_object* const pend = o.via.array.ptr + o.via.array.size; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, *p); - } - } - fprintf(out, "]"); - break; + case MSGPACK_OBJECT_ARRAY: + fprintf(out, "["); + if(o.via.array.size != 0) { + msgpack_object* p = o.via.array.ptr; + msgpack_object_print(out, *p); + ++p; + msgpack_object* const pend = o.via.array.ptr + o.via.array.size; + for(; p < pend; ++p) { + fprintf(out, ", "); + msgpack_object_print(out, *p); + } + } + fprintf(out, "]"); + break; - case MSGPACK_OBJECT_MAP: - fprintf(out, "{"); - if(o.via.map.size != 0) { - msgpack_object_kv* p = o.via.map.ptr; - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - ++p; - msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - } - } - fprintf(out, "}"); - break; + case MSGPACK_OBJECT_MAP: + fprintf(out, "{"); + if(o.via.map.size != 0) { + msgpack_object_kv* p = o.via.map.ptr; + msgpack_object_print(out, p->key); + fprintf(out, "=>"); + msgpack_object_print(out, p->val); + ++p; + msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; + for(; p < pend; ++p) { + fprintf(out, ", "); + msgpack_object_print(out, p->key); + fprintf(out, "=>"); + msgpack_object_print(out, p->val); + } + } + fprintf(out, "}"); + break; - default: - // FIXME - fprintf(out, "#", o.type, o.via.u64); - } + default: + // FIXME + fprintf(out, "#", o.type, o.via.u64); + } } bool msgpack_object_equal(const msgpack_object x, const msgpack_object y) { - if(x.type != y.type) { return false; } + if(x.type != y.type) { return false; } - switch(x.type) { - case MSGPACK_OBJECT_NIL: - return true; + switch(x.type) { + case MSGPACK_OBJECT_NIL: + return true; - case MSGPACK_OBJECT_BOOLEAN: - return x.via.boolean == y.via.boolean; + case MSGPACK_OBJECT_BOOLEAN: + return x.via.boolean == y.via.boolean; - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return x.via.u64 == y.via.u64; + case MSGPACK_OBJECT_POSITIVE_INTEGER: + return x.via.u64 == y.via.u64; - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return x.via.i64 == y.via.i64; + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + return x.via.i64 == y.via.i64; - case MSGPACK_OBJECT_DOUBLE: - return x.via.dec == y.via.dec; + case MSGPACK_OBJECT_DOUBLE: + return x.via.dec == y.via.dec; - case MSGPACK_OBJECT_STR: - return x.via.str.size == y.via.str.size && - memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; + case MSGPACK_OBJECT_STR: + return x.via.str.size == y.via.str.size && + memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; - case MSGPACK_OBJECT_BIN: - return x.via.bin.size == y.via.bin.size && - memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + case MSGPACK_OBJECT_BIN: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; - case MSGPACK_OBJECT_ARRAY: - if(x.via.array.size != y.via.array.size) { - return false; - } else if(x.via.array.size == 0) { - return true; - } else { - msgpack_object* px = x.via.array.ptr; - msgpack_object* const pxend = x.via.array.ptr + x.via.array.size; - msgpack_object* py = y.via.array.ptr; - do { - if(!msgpack_object_equal(*px, *py)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } + case MSGPACK_OBJECT_ARRAY: + if(x.via.array.size != y.via.array.size) { + return false; + } else if(x.via.array.size == 0) { + return true; + } else { + msgpack_object* px = x.via.array.ptr; + msgpack_object* const pxend = x.via.array.ptr + x.via.array.size; + msgpack_object* py = y.via.array.ptr; + do { + if(!msgpack_object_equal(*px, *py)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } - case MSGPACK_OBJECT_MAP: - if(x.via.map.size != y.via.map.size) { - return false; - } else if(x.via.map.size == 0) { - return true; - } else { - msgpack_object_kv* px = x.via.map.ptr; - msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size; - msgpack_object_kv* py = y.via.map.ptr; - do { - if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } + case MSGPACK_OBJECT_MAP: + if(x.via.map.size != y.via.map.size) { + return false; + } else if(x.via.map.size == 0) { + return true; + } else { + msgpack_object_kv* px = x.via.map.ptr; + msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size; + msgpack_object_kv* py = y.via.map.ptr; + do { + if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } - default: - return false; - } + default: + return false; + } } diff --git a/src/unpack.c b/src/unpack.c index 005777e1..01661055 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -25,19 +25,19 @@ typedef struct { - msgpack_zone* z; - bool referenced; + msgpack_zone* z; + bool referenced; } unpack_user; #define msgpack_unpack_struct(name) \ - struct template ## name + struct template ## name #define msgpack_unpack_func(ret, name) \ - ret template ## name + ret template ## name #define msgpack_unpack_callback(name) \ - template_callback ## name + template_callback ## name #define msgpack_unpack_object msgpack_object @@ -51,8 +51,8 @@ static void template_init(template_context* ctx); static msgpack_object template_data(template_context* ctx); -static int template_execute(template_context* ctx, - const char* data, size_t len, size_t* off); +static int template_execute( + template_context* ctx, const char* data, size_t len, size_t* off); static inline msgpack_object template_callback_root(unpack_user* u) @@ -72,19 +72,19 @@ static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack_o static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack_object* o) { if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack_object* o) { if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack_object* o) { if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_object* o) { if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } + else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o) { o->type = MSGPACK_OBJECT_DOUBLE; o->via.dec = d; return 0; } @@ -103,62 +103,62 @@ static inline int template_callback_false(unpack_user* u, msgpack_object* o) static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o) { - o->type = MSGPACK_OBJECT_ARRAY; - o->via.array.size = 0; - o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object)); - if(o->via.array.ptr == NULL) { return -1; } - return 0; + o->type = MSGPACK_OBJECT_ARRAY; + o->via.array.size = 0; + o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object)); + if(o->via.array.ptr == NULL) { return -1; } + return 0; } static inline int template_callback_array_item(unpack_user* u, msgpack_object* c, msgpack_object o) { #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); + memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); #else /* __GNUC__ && !__clang__ */ - c->via.array.ptr[c->via.array.size] = o; + c->via.array.ptr[c->via.array.size] = o; #endif /* __GNUC__ && !__clang__ */ - ++c->via.array.size; - return 0; + ++c->via.array.size; + return 0; } static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o) { - o->type = MSGPACK_OBJECT_MAP; - o->via.map.size = 0; - o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv)); - if(o->via.map.ptr == NULL) { return -1; } - return 0; + o->type = MSGPACK_OBJECT_MAP; + o->via.map.size = 0; + o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv)); + if(o->via.map.ptr == NULL) { return -1; } + return 0; } static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v) { #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); - memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); + memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); + memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); #else /* __GNUC__ && !__clang__ */ - c->via.map.ptr[c->via.map.size].key = k; - c->via.map.ptr[c->via.map.size].val = v; + c->via.map.ptr[c->via.map.size].key = k; + c->via.map.ptr[c->via.map.size].val = v; #endif /* __GNUC__ && !__clang__ */ - ++c->via.map.size; - return 0; + ++c->via.map.size; + return 0; } static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { - o->type = MSGPACK_OBJECT_STR; - o->via.str.ptr = p; - o->via.str.size = l; - u->referenced = true; - return 0; + o->type = MSGPACK_OBJECT_STR; + o->via.str.ptr = p; + o->via.str.size = l; + u->referenced = true; + return 0; } static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { - o->type = MSGPACK_OBJECT_BIN; - o->via.bin.ptr = p; - o->via.bin.size = l; - u->referenced = true; - return 0; + o->type = MSGPACK_OBJECT_BIN; + o->via.bin.ptr = p; + o->via.bin.size = l; + u->referenced = true; + return 0; } #include "msgpack/unpack_template.h" @@ -172,316 +172,316 @@ static inline int template_callback_bin(unpack_user* u, const char* b, const cha static inline void init_count(void* buffer) { - *(volatile _msgpack_atomic_counter_t*)buffer = 1; + *(volatile _msgpack_atomic_counter_t*)buffer = 1; } static inline void decl_count(void* buffer) { - // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); } - if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) { - free(buffer); - } + // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); } + if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) { + free(buffer); + } } static inline void incr_count(void* buffer) { - // atomic ++*(_msgpack_atomic_counter_t*)buffer; - _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer); + // atomic ++*(_msgpack_atomic_counter_t*)buffer; + _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer); } static inline _msgpack_atomic_counter_t get_count(void* buffer) { - return *(volatile _msgpack_atomic_counter_t*)buffer; + return *(volatile _msgpack_atomic_counter_t*)buffer; } bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size) { - if(initial_buffer_size < COUNTER_SIZE) { - initial_buffer_size = COUNTER_SIZE; - } + if(initial_buffer_size < COUNTER_SIZE) { + initial_buffer_size = COUNTER_SIZE; + } - char* buffer = (char*)malloc(initial_buffer_size); - if(buffer == NULL) { - return false; - } + char* buffer = (char*)malloc(initial_buffer_size); + if(buffer == NULL) { + return false; + } - void* ctx = malloc(sizeof(template_context)); - if(ctx == NULL) { - free(buffer); - return false; - } + void* ctx = malloc(sizeof(template_context)); + if(ctx == NULL) { + free(buffer); + return false; + } - msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(z == NULL) { - free(ctx); - free(buffer); - return false; - } + msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(z == NULL) { + free(ctx); + free(buffer); + return false; + } - mpac->buffer = buffer; - mpac->used = COUNTER_SIZE; - mpac->free = initial_buffer_size - mpac->used; - mpac->off = COUNTER_SIZE; - mpac->parsed = 0; - mpac->initial_buffer_size = initial_buffer_size; - mpac->z = z; - mpac->ctx = ctx; + mpac->buffer = buffer; + mpac->used = COUNTER_SIZE; + mpac->free = initial_buffer_size - mpac->used; + mpac->off = COUNTER_SIZE; + mpac->parsed = 0; + mpac->initial_buffer_size = initial_buffer_size; + mpac->z = z; + mpac->ctx = ctx; - init_count(mpac->buffer); + init_count(mpac->buffer); - template_init(CTX_CAST(mpac->ctx)); - CTX_CAST(mpac->ctx)->user.z = mpac->z; - CTX_CAST(mpac->ctx)->user.referenced = false; + template_init(CTX_CAST(mpac->ctx)); + CTX_CAST(mpac->ctx)->user.z = mpac->z; + CTX_CAST(mpac->ctx)->user.referenced = false; - return true; + return true; } void msgpack_unpacker_destroy(msgpack_unpacker* mpac) { - msgpack_zone_free(mpac->z); - free(mpac->ctx); - decl_count(mpac->buffer); + msgpack_zone_free(mpac->z); + free(mpac->ctx); + decl_count(mpac->buffer); } msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size) { - msgpack_unpacker* mpac = (msgpack_unpacker*)malloc(sizeof(msgpack_unpacker)); - if(mpac == NULL) { - return NULL; - } + msgpack_unpacker* mpac = (msgpack_unpacker*)malloc(sizeof(msgpack_unpacker)); + if(mpac == NULL) { + return NULL; + } - if(!msgpack_unpacker_init(mpac, initial_buffer_size)) { - free(mpac); - return NULL; - } + if(!msgpack_unpacker_init(mpac, initial_buffer_size)) { + free(mpac); + return NULL; + } - return mpac; + return mpac; } void msgpack_unpacker_free(msgpack_unpacker* mpac) { - msgpack_unpacker_destroy(mpac); - free(mpac); + msgpack_unpacker_destroy(mpac); + free(mpac); } bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size) { - if(mpac->used == mpac->off && get_count(mpac->buffer) == 1 - && !CTX_REFERENCED(mpac)) { - // rewind buffer - mpac->free += mpac->used - COUNTER_SIZE; - mpac->used = COUNTER_SIZE; - mpac->off = COUNTER_SIZE; + if(mpac->used == mpac->off && get_count(mpac->buffer) == 1 + && !CTX_REFERENCED(mpac)) { + // rewind buffer + mpac->free += mpac->used - COUNTER_SIZE; + mpac->used = COUNTER_SIZE; + mpac->off = COUNTER_SIZE; - if(mpac->free >= size) { - return true; - } - } + if(mpac->free >= size) { + return true; + } + } - if(mpac->off == COUNTER_SIZE) { - size_t next_size = (mpac->used + mpac->free) * 2; // include COUNTER_SIZE - while(next_size < size + mpac->used) { - next_size *= 2; - } + if(mpac->off == COUNTER_SIZE) { + size_t next_size = (mpac->used + mpac->free) * 2; // include COUNTER_SIZE + while(next_size < size + mpac->used) { + next_size *= 2; + } - char* tmp = (char*)realloc(mpac->buffer, next_size); - if(tmp == NULL) { - return false; - } + char* tmp = (char*)realloc(mpac->buffer, next_size); + if(tmp == NULL) { + return false; + } - mpac->buffer = tmp; - mpac->free = next_size - mpac->used; + mpac->buffer = tmp; + mpac->free = next_size - mpac->used; - } else { - size_t next_size = mpac->initial_buffer_size; // include COUNTER_SIZE - size_t not_parsed = mpac->used - mpac->off; - while(next_size < size + not_parsed + COUNTER_SIZE) { - next_size *= 2; - } + } else { + size_t next_size = mpac->initial_buffer_size; // include COUNTER_SIZE + size_t not_parsed = mpac->used - mpac->off; + while(next_size < size + not_parsed + COUNTER_SIZE) { + next_size *= 2; + } - char* tmp = (char*)malloc(next_size); - if(tmp == NULL) { - return false; - } + char* tmp = (char*)malloc(next_size); + if(tmp == NULL) { + return false; + } - init_count(tmp); + init_count(tmp); - memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed); + memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed); - if(CTX_REFERENCED(mpac)) { - if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { - free(tmp); - return false; - } - CTX_REFERENCED(mpac) = false; - } else { - decl_count(mpac->buffer); - } + if(CTX_REFERENCED(mpac)) { + if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { + free(tmp); + return false; + } + CTX_REFERENCED(mpac) = false; + } else { + decl_count(mpac->buffer); + } - mpac->buffer = tmp; - mpac->used = not_parsed + COUNTER_SIZE; - mpac->free = next_size - mpac->used; - mpac->off = COUNTER_SIZE; - } + mpac->buffer = tmp; + mpac->used = not_parsed + COUNTER_SIZE; + mpac->free = next_size - mpac->used; + mpac->off = COUNTER_SIZE; + } - return true; + return true; } int msgpack_unpacker_execute(msgpack_unpacker* mpac) { - size_t off = mpac->off; - int ret = template_execute(CTX_CAST(mpac->ctx), - mpac->buffer, mpac->used, &mpac->off); - if(mpac->off > off) { - mpac->parsed += mpac->off - off; - } - return ret; + size_t off = mpac->off; + int ret = template_execute(CTX_CAST(mpac->ctx), + mpac->buffer, mpac->used, &mpac->off); + if(mpac->off > off) { + mpac->parsed += mpac->off - off; + } + return ret; } msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac) { - return template_data(CTX_CAST(mpac->ctx)); + return template_data(CTX_CAST(mpac->ctx)); } msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac) { - if(!msgpack_unpacker_flush_zone(mpac)) { - return NULL; - } + if(!msgpack_unpacker_flush_zone(mpac)) { + return NULL; + } - msgpack_zone* r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(r == NULL) { - return NULL; - } + msgpack_zone* r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(r == NULL) { + return NULL; + } - msgpack_zone* old = mpac->z; - mpac->z = r; - CTX_CAST(mpac->ctx)->user.z = mpac->z; + msgpack_zone* old = mpac->z; + mpac->z = r; + CTX_CAST(mpac->ctx)->user.z = mpac->z; - return old; + return old; } void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac) { - msgpack_zone_clear(mpac->z); + msgpack_zone_clear(mpac->z); } bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac) { - if(CTX_REFERENCED(mpac)) { - if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { - return false; - } - CTX_REFERENCED(mpac) = false; + if(CTX_REFERENCED(mpac)) { + if(!msgpack_zone_push_finalizer(mpac->z, decl_count, mpac->buffer)) { + return false; + } + CTX_REFERENCED(mpac) = false; - incr_count(mpac->buffer); - } + incr_count(mpac->buffer); + } - return true; + return true; } void msgpack_unpacker_reset(msgpack_unpacker* mpac) { - template_init(CTX_CAST(mpac->ctx)); - // don't reset referenced flag - mpac->parsed = 0; + template_init(CTX_CAST(mpac->ctx)); + // don't reset referenced flag + mpac->parsed = 0; } bool msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone_free(result->zone); - } + if(result->zone != NULL) { + msgpack_zone_free(result->zone); + } - int ret = msgpack_unpacker_execute(mpac); + int ret = msgpack_unpacker_execute(mpac); - if(ret <= 0) { - result->zone = NULL; - memset(&result->data, 0, sizeof(msgpack_object)); - return false; - } + if(ret <= 0) { + result->zone = NULL; + memset(&result->data, 0, sizeof(msgpack_object)); + return false; + } - result->zone = msgpack_unpacker_release_zone(mpac); - result->data = msgpack_unpacker_data(mpac); - msgpack_unpacker_reset(mpac); + result->zone = msgpack_unpacker_release_zone(mpac); + result->data = msgpack_unpacker_data(mpac); + msgpack_unpacker_reset(mpac); - return true; + return true; } msgpack_unpack_return msgpack_unpack(const char* data, size_t len, size_t* off, - msgpack_zone* result_zone, msgpack_object* result) + msgpack_zone* result_zone, msgpack_object* result) { - size_t noff = 0; - if(off != NULL) { noff = *off; } + size_t noff = 0; + if(off != NULL) { noff = *off; } - if(len <= noff) { - // FIXME - return MSGPACK_UNPACK_CONTINUE; - } + if(len <= noff) { + // FIXME + return MSGPACK_UNPACK_CONTINUE; + } - template_context ctx; - template_init(&ctx); + template_context ctx; + template_init(&ctx); - ctx.user.z = result_zone; - ctx.user.referenced = false; + ctx.user.z = result_zone; + ctx.user.referenced = false; - int e = template_execute(&ctx, data, len, &noff); - if(e < 0) { - return MSGPACK_UNPACK_PARSE_ERROR; - } + int e = template_execute(&ctx, data, len, &noff); + if(e < 0) { + return MSGPACK_UNPACK_PARSE_ERROR; + } - if(off != NULL) { *off = noff; } + if(off != NULL) { *off = noff; } - if(e == 0) { - return MSGPACK_UNPACK_CONTINUE; - } + if(e == 0) { + return MSGPACK_UNPACK_CONTINUE; + } - *result = template_data(&ctx); + *result = template_data(&ctx); - if(noff < len) { - return MSGPACK_UNPACK_EXTRA_BYTES; - } + if(noff < len) { + return MSGPACK_UNPACK_EXTRA_BYTES; + } - return MSGPACK_UNPACK_SUCCESS; + return MSGPACK_UNPACK_SUCCESS; } bool msgpack_unpack_next(msgpack_unpacked* result, - const char* data, size_t len, size_t* off) + const char* data, size_t len, size_t* off) { - msgpack_unpacked_destroy(result); + msgpack_unpacked_destroy(result); - size_t noff = 0; - if(off != NULL) { noff = *off; } + size_t noff = 0; + if(off != NULL) { noff = *off; } - if(len <= noff) { - return false; - } + if(len <= noff) { + return false; + } - msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - template_context ctx; - template_init(&ctx); + template_context ctx; + template_init(&ctx); - ctx.user.z = z; - ctx.user.referenced = false; + ctx.user.z = z; + ctx.user.referenced = false; - int e = template_execute(&ctx, data, len, &noff); - if(e <= 0) { - msgpack_zone_free(z); - return false; - } + int e = template_execute(&ctx, data, len, &noff); + if(e <= 0) { + msgpack_zone_free(z); + return false; + } - if(off != NULL) { *off = noff; } + if(off != NULL) { *off = noff; } - result->zone = z; - result->data = template_data(&ctx); + result->zone = z; + result->data = template_data(&ctx); - return true; + return true; } #if defined(MSGPACK_OLD_COMPILER_BUS_ERROR_WORKAROUND) diff --git a/src/version.c b/src/version.c index 3d956f18..78e06527 100644 --- a/src/version.c +++ b/src/version.c @@ -2,16 +2,16 @@ const char* msgpack_version(void) { - return MSGPACK_VERSION; + return MSGPACK_VERSION; } int msgpack_version_major(void) { - return MSGPACK_VERSION_MAJOR; + return MSGPACK_VERSION_MAJOR; } int msgpack_version_minor(void) { - return MSGPACK_VERSION_MINOR; + return MSGPACK_VERSION_MINOR; } diff --git a/src/vrefbuffer.c b/src/vrefbuffer.c index d43fb6d2..ec5a0ead 100644 --- a/src/vrefbuffer.c +++ b/src/vrefbuffer.c @@ -20,201 +20,201 @@ #include struct msgpack_vrefbuffer_chunk { - struct msgpack_vrefbuffer_chunk* next; - /* data ... */ + struct msgpack_vrefbuffer_chunk* next; + /* data ... */ }; bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, - size_t ref_size, size_t chunk_size) + size_t ref_size, size_t chunk_size) { - vbuf->chunk_size = chunk_size; - vbuf->ref_size = ref_size; + vbuf->chunk_size = chunk_size; + vbuf->ref_size = ref_size; - size_t nfirst = (sizeof(struct iovec) < 72/2) ? - 72 / sizeof(struct iovec) : 8; + size_t nfirst = (sizeof(struct iovec) < 72/2) ? + 72 / sizeof(struct iovec) : 8; - struct iovec* array = (struct iovec*)malloc( - sizeof(struct iovec) * nfirst); - if(array == NULL) { - return false; - } + struct iovec* array = (struct iovec*)malloc( + sizeof(struct iovec) * nfirst); + if(array == NULL) { + return false; + } - vbuf->tail = array; - vbuf->end = array + nfirst; - vbuf->array = array; + vbuf->tail = array; + vbuf->end = array + nfirst; + vbuf->array = array; - msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + chunk_size); - if(chunk == NULL) { - free(array); - return false; - } + msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( + sizeof(msgpack_vrefbuffer_chunk) + chunk_size); + if(chunk == NULL) { + free(array); + return false; + } - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - ib->free = chunk_size; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - ib->head = chunk; - chunk->next = NULL; + ib->free = chunk_size; + ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); + ib->head = chunk; + chunk->next = NULL; - return true; + return true; } void msgpack_vrefbuffer_destroy(msgpack_vrefbuffer* vbuf) { - msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head; - while(true) { - msgpack_vrefbuffer_chunk* n = c->next; - free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } - free(vbuf->array); + msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head; + while(true) { + msgpack_vrefbuffer_chunk* n = c->next; + free(c); + if(n != NULL) { + c = n; + } else { + break; + } + } + free(vbuf->array); } void msgpack_vrefbuffer_clear(msgpack_vrefbuffer* vbuf) { - msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head->next; - msgpack_vrefbuffer_chunk* n; - while(c != NULL) { - n = c->next; - free(c); - c = n; - } + msgpack_vrefbuffer_chunk* c = vbuf->inner_buffer.head->next; + msgpack_vrefbuffer_chunk* n; + while(c != NULL) { + n = c->next; + free(c); + c = n; + } - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - msgpack_vrefbuffer_chunk* chunk = ib->head; - chunk->next = NULL; - ib->free = vbuf->chunk_size; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_chunk* chunk = ib->head; + chunk->next = NULL; + ib->free = vbuf->chunk_size; + ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - vbuf->tail = vbuf->array; + vbuf->tail = vbuf->array; } int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len) + const char* buf, size_t len) { - if(vbuf->tail == vbuf->end) { - const size_t nused = (size_t)(vbuf->tail - vbuf->array); - const size_t nnext = nused * 2; + if(vbuf->tail == vbuf->end) { + const size_t nused = (size_t)(vbuf->tail - vbuf->array); + const size_t nnext = nused * 2; - struct iovec* nvec = (struct iovec*)realloc( - vbuf->array, sizeof(struct iovec)*nnext); - if(nvec == NULL) { - return -1; - } + struct iovec* nvec = (struct iovec*)realloc( + vbuf->array, sizeof(struct iovec)*nnext); + if(nvec == NULL) { + return -1; + } - vbuf->array = nvec; - vbuf->end = nvec + nnext; - vbuf->tail = nvec + nused; - } + vbuf->array = nvec; + vbuf->end = nvec + nnext; + vbuf->tail = nvec + nused; + } - vbuf->tail->iov_base = (char*)buf; - vbuf->tail->iov_len = len; - ++vbuf->tail; + vbuf->tail->iov_base = (char*)buf; + vbuf->tail->iov_len = len; + ++vbuf->tail; - return 0; + return 0; } int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, - const char* buf, size_t len) + const char* buf, size_t len) { - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - if(ib->free < len) { - size_t sz = vbuf->chunk_size; - if(sz < len) { - sz = len; - } + if(ib->free < len) { + size_t sz = vbuf->chunk_size; + if(sz < len) { + sz = len; + } - msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + sz); - if(chunk == NULL) { - return -1; - } + msgpack_vrefbuffer_chunk* chunk = (msgpack_vrefbuffer_chunk*)malloc( + sizeof(msgpack_vrefbuffer_chunk) + sz); + if(chunk == NULL) { + return -1; + } - chunk->next = ib->head; - ib->head = chunk; - ib->free = sz; - ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); - } + chunk->next = ib->head; + ib->head = chunk; + ib->free = sz; + ib->ptr = ((char*)chunk) + sizeof(msgpack_vrefbuffer_chunk); + } - char* m = ib->ptr; - memcpy(m, buf, len); - ib->free -= len; - ib->ptr += len; + char* m = ib->ptr; + memcpy(m, buf, len); + ib->free -= len; + ib->ptr += len; - if(vbuf->tail != vbuf->array && m == - (const char*)((vbuf->tail-1)->iov_base) + (vbuf->tail-1)->iov_len) { - (vbuf->tail-1)->iov_len += len; - return 0; - } else { - return msgpack_vrefbuffer_append_ref(vbuf, m, len); - } + if(vbuf->tail != vbuf->array && m == + (const char*)((vbuf->tail-1)->iov_base) + (vbuf->tail-1)->iov_len) { + (vbuf->tail-1)->iov_len += len; + return 0; + } else { + return msgpack_vrefbuffer_append_ref(vbuf, m, len); + } } int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) { - size_t sz = vbuf->chunk_size; + size_t sz = vbuf->chunk_size; - msgpack_vrefbuffer_chunk* empty = (msgpack_vrefbuffer_chunk*)malloc( - sizeof(msgpack_vrefbuffer_chunk) + sz); - if(empty == NULL) { - return -1; - } + msgpack_vrefbuffer_chunk* empty = (msgpack_vrefbuffer_chunk*)malloc( + sizeof(msgpack_vrefbuffer_chunk) + sz); + if(empty == NULL) { + return -1; + } - empty->next = NULL; + empty->next = NULL; - const size_t nused = (size_t)(vbuf->tail - vbuf->array); - if(to->tail + nused < vbuf->end) { - const size_t tosize = (size_t)(to->tail - to->array); - const size_t reqsize = nused + tosize; - size_t nnext = (size_t)(to->end - to->array) * 2; - while(nnext < reqsize) { - nnext *= 2; - } + const size_t nused = (size_t)(vbuf->tail - vbuf->array); + if(to->tail + nused < vbuf->end) { + const size_t tosize = (size_t)(to->tail - to->array); + const size_t reqsize = nused + tosize; + size_t nnext = (size_t)(to->end - to->array) * 2; + while(nnext < reqsize) { + nnext *= 2; + } - struct iovec* nvec = (struct iovec*)realloc( - to->array, sizeof(struct iovec)*nnext); - if(nvec == NULL) { - free(empty); - return -1; - } + struct iovec* nvec = (struct iovec*)realloc( + to->array, sizeof(struct iovec)*nnext); + if(nvec == NULL) { + free(empty); + return -1; + } - to->array = nvec; - to->end = nvec + nnext; - to->tail = nvec + tosize; - } + to->array = nvec; + to->end = nvec + nnext; + to->tail = nvec + tosize; + } - memcpy(to->tail, vbuf->array, sizeof(struct iovec)*nused); + memcpy(to->tail, vbuf->array, sizeof(struct iovec)*nused); - to->tail += nused; - vbuf->tail = vbuf->array; + to->tail += nused; + vbuf->tail = vbuf->array; - msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; - msgpack_vrefbuffer_inner_buffer* const toib = &to->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const ib = &vbuf->inner_buffer; + msgpack_vrefbuffer_inner_buffer* const toib = &to->inner_buffer; - msgpack_vrefbuffer_chunk* last = ib->head; - while(last->next != NULL) { - last = last->next; - } - last->next = toib->head; - toib->head = ib->head; + msgpack_vrefbuffer_chunk* last = ib->head; + while(last->next != NULL) { + last = last->next; + } + last->next = toib->head; + toib->head = ib->head; - if(toib->free < ib->free) { - toib->free = ib->free; - toib->ptr = ib->ptr; - } + if(toib->free < ib->free) { + toib->free = ib->free; + toib->ptr = ib->ptr; + } - ib->head = empty; - ib->free = sz; - ib->ptr = ((char*)empty) + sizeof(msgpack_vrefbuffer_chunk); + ib->head = empty; + ib->free = sz; + ib->ptr = ((char*)empty) + sizeof(msgpack_vrefbuffer_chunk); - return 0; + return 0; } diff --git a/src/zone.c b/src/zone.c index f982cf7c..9110e35d 100644 --- a/src/zone.c +++ b/src/zone.c @@ -20,202 +20,202 @@ #include struct msgpack_zone_chunk { - struct msgpack_zone_chunk* next; - /* data ... */ + struct msgpack_zone_chunk* next; + /* data ... */ }; static inline bool init_chunk_list(msgpack_zone_chunk_list* cl, size_t chunk_size) { - msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( - sizeof(msgpack_zone_chunk) + chunk_size); - if(chunk == NULL) { - return false; - } + msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( + sizeof(msgpack_zone_chunk) + chunk_size); + if(chunk == NULL) { + return false; + } - cl->head = chunk; - cl->free = chunk_size; - cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); - chunk->next = NULL; + cl->head = chunk; + cl->free = chunk_size; + cl->ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); + chunk->next = NULL; - return true; + return true; } static inline void destroy_chunk_list(msgpack_zone_chunk_list* cl) { - msgpack_zone_chunk* c = cl->head; - while(true) { - msgpack_zone_chunk* n = c->next; - free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } + msgpack_zone_chunk* c = cl->head; + while(true) { + msgpack_zone_chunk* n = c->next; + free(c); + if(n != NULL) { + c = n; + } else { + break; + } + } } static inline void clear_chunk_list(msgpack_zone_chunk_list* cl, size_t chunk_size) { - msgpack_zone_chunk* c = cl->head; - while(true) { - msgpack_zone_chunk* n = c->next; - if(n != NULL) { - free(c); - c = n; - } else { - cl->head = c; - break; - } - } - cl->head->next = NULL; - cl->free = chunk_size; - cl->ptr = ((char*)cl->head) + sizeof(msgpack_zone_chunk); + msgpack_zone_chunk* c = cl->head; + while(true) { + msgpack_zone_chunk* n = c->next; + if(n != NULL) { + free(c); + c = n; + } else { + cl->head = c; + break; + } + } + cl->head->next = NULL; + cl->free = chunk_size; + cl->ptr = ((char*)cl->head) + sizeof(msgpack_zone_chunk); } void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size) { - msgpack_zone_chunk_list* const cl = &zone->chunk_list; + msgpack_zone_chunk_list* const cl = &zone->chunk_list; - size_t sz = zone->chunk_size; + size_t sz = zone->chunk_size; - while(sz < size) { - sz *= 2; - } + while(sz < size) { + sz *= 2; + } - msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( - sizeof(msgpack_zone_chunk) + sz); - if (chunk == NULL) return NULL; - char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); - chunk->next = cl->head; - cl->head = chunk; - cl->free = sz - size; - cl->ptr = ptr + size; + msgpack_zone_chunk* chunk = (msgpack_zone_chunk*)malloc( + sizeof(msgpack_zone_chunk) + sz); + if (chunk == NULL) return NULL; + char* ptr = ((char*)chunk) + sizeof(msgpack_zone_chunk); + chunk->next = cl->head; + cl->head = chunk; + cl->free = sz - size; + cl->ptr = ptr + size; - return ptr; + return ptr; } static inline void init_finalizer_array(msgpack_zone_finalizer_array* fa) { - fa->tail = NULL; - fa->end = NULL; - fa->array = NULL; + fa->tail = NULL; + fa->end = NULL; + fa->array = NULL; } static inline void call_finalizer_array(msgpack_zone_finalizer_array* fa) { - msgpack_zone_finalizer* fin = fa->tail; - for(; fin != fa->array; --fin) { - (*(fin-1)->func)((fin-1)->data); - } + msgpack_zone_finalizer* fin = fa->tail; + for(; fin != fa->array; --fin) { + (*(fin-1)->func)((fin-1)->data); + } } static inline void destroy_finalizer_array(msgpack_zone_finalizer_array* fa) { - call_finalizer_array(fa); - free(fa->array); + call_finalizer_array(fa); + free(fa->array); } static inline void clear_finalizer_array(msgpack_zone_finalizer_array* fa) { - call_finalizer_array(fa); - fa->tail = fa->array; + call_finalizer_array(fa); + fa->tail = fa->array; } bool msgpack_zone_push_finalizer_expand(msgpack_zone* zone, - void (*func)(void* data), void* data) + void (*func)(void* data), void* data) { - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; + msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - const size_t nused = (size_t)(fa->end - fa->array); + const size_t nused = (size_t)(fa->end - fa->array); - size_t nnext; - if(nused == 0) { - nnext = (sizeof(msgpack_zone_finalizer) < 72/2) ? - 72 / sizeof(msgpack_zone_finalizer) : 8; + size_t nnext; + if(nused == 0) { + nnext = (sizeof(msgpack_zone_finalizer) < 72/2) ? + 72 / sizeof(msgpack_zone_finalizer) : 8; - } else { - nnext = nused * 2; - } + } else { + nnext = nused * 2; + } - msgpack_zone_finalizer* tmp = - (msgpack_zone_finalizer*)realloc(fa->array, - sizeof(msgpack_zone_finalizer) * nnext); - if(tmp == NULL) { - return false; - } + msgpack_zone_finalizer* tmp = + (msgpack_zone_finalizer*)realloc(fa->array, + sizeof(msgpack_zone_finalizer) * nnext); + if(tmp == NULL) { + return false; + } - fa->array = tmp; - fa->end = tmp + nnext; - fa->tail = tmp + nused; + fa->array = tmp; + fa->end = tmp + nnext; + fa->tail = tmp + nused; - fa->tail->func = func; - fa->tail->data = data; + fa->tail->func = func; + fa->tail->data = data; - ++fa->tail; + ++fa->tail; - return true; + return true; } bool msgpack_zone_is_empty(msgpack_zone* zone) { - msgpack_zone_chunk_list* const cl = &zone->chunk_list; - msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; - return cl->free == zone->chunk_size && cl->head->next == NULL && - fa->tail == fa->array; + msgpack_zone_chunk_list* const cl = &zone->chunk_list; + msgpack_zone_finalizer_array* const fa = &zone->finalizer_array; + return cl->free == zone->chunk_size && cl->head->next == NULL && + fa->tail == fa->array; } void msgpack_zone_destroy(msgpack_zone* zone) { - destroy_finalizer_array(&zone->finalizer_array); - destroy_chunk_list(&zone->chunk_list); + destroy_finalizer_array(&zone->finalizer_array); + destroy_chunk_list(&zone->chunk_list); } void msgpack_zone_clear(msgpack_zone* zone) { - clear_finalizer_array(&zone->finalizer_array); - clear_chunk_list(&zone->chunk_list, zone->chunk_size); + clear_finalizer_array(&zone->finalizer_array); + clear_chunk_list(&zone->chunk_list, zone->chunk_size); } bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size) { - zone->chunk_size = chunk_size; + zone->chunk_size = chunk_size; - if(!init_chunk_list(&zone->chunk_list, chunk_size)) { - return false; - } + if(!init_chunk_list(&zone->chunk_list, chunk_size)) { + return false; + } - init_finalizer_array(&zone->finalizer_array); + init_finalizer_array(&zone->finalizer_array); - return true; + return true; } msgpack_zone* msgpack_zone_new(size_t chunk_size) { - msgpack_zone* zone = (msgpack_zone*)malloc( - sizeof(msgpack_zone) + chunk_size); - if(zone == NULL) { - return NULL; - } + msgpack_zone* zone = (msgpack_zone*)malloc( + sizeof(msgpack_zone) + chunk_size); + if(zone == NULL) { + return NULL; + } - zone->chunk_size = chunk_size; + zone->chunk_size = chunk_size; - if(!init_chunk_list(&zone->chunk_list, chunk_size)) { - free(zone); - return NULL; - } + if(!init_chunk_list(&zone->chunk_list, chunk_size)) { + free(zone); + return NULL; + } - init_finalizer_array(&zone->finalizer_array); + init_finalizer_array(&zone->finalizer_array); - return zone; + return zone; } void msgpack_zone_free(msgpack_zone* zone) { - if(zone == NULL) { return; } - msgpack_zone_destroy(zone); - free(zone); + if(zone == NULL) { return; } + msgpack_zone_destroy(zone); + free(zone); } diff --git a/test/buffer.cc b/test/buffer.cc index 35d731a5..b72aeddf 100644 --- a/test/buffer.cc +++ b/test/buffer.cc @@ -7,114 +7,114 @@ TEST(buffer, sbuffer) { - msgpack::sbuffer sbuf; - sbuf.write("a", 1); - sbuf.write("a", 1); - sbuf.write("a", 1); + msgpack::sbuffer sbuf; + sbuf.write("a", 1); + sbuf.write("a", 1); + sbuf.write("a", 1); - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); - sbuf.clear(); - sbuf.write("a", 1); - sbuf.write("a", 1); - sbuf.write("a", 1); + sbuf.clear(); + sbuf.write("a", 1); + sbuf.write("a", 1); + sbuf.write("a", 1); - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); } TEST(buffer, vrefbuffer) { - msgpack::vrefbuffer vbuf; - vbuf.write("a", 1); - vbuf.write("a", 1); - vbuf.write("a", 1); + msgpack::vrefbuffer vbuf; + vbuf.write("a", 1); + vbuf.write("a", 1); + vbuf.write("a", 1); - const struct iovec* vec = vbuf.vector(); - size_t veclen = vbuf.vector_size(); + const struct iovec* vec = vbuf.vector(); + size_t veclen = vbuf.vector_size(); - msgpack::sbuffer sbuf; - for(size_t i=0; i < veclen; ++i) { - sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); - } + msgpack::sbuffer sbuf; + for(size_t i=0; i < veclen; ++i) { + sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); + } - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); - vbuf.clear(); - vbuf.write("a", 1); - vbuf.write("a", 1); - vbuf.write("a", 1); + vbuf.clear(); + vbuf.write("a", 1); + vbuf.write("a", 1); + vbuf.write("a", 1); - vec = vbuf.vector(); - veclen = vbuf.vector_size(); + vec = vbuf.vector(); + veclen = vbuf.vector_size(); - sbuf.clear(); - for(size_t i=0; i < veclen; ++i) { - sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); - } + sbuf.clear(); + for(size_t i=0; i < veclen; ++i) { + sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); + } - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); } TEST(buffer, zbuffer) { - msgpack::zbuffer zbuf; - zbuf.write("a", 1); - zbuf.write("a", 1); - zbuf.write("a", 1); + msgpack::zbuffer zbuf; + zbuf.write("a", 1); + zbuf.write("a", 1); + zbuf.write("a", 1); - zbuf.flush(); + zbuf.flush(); } TEST(buffer, fbuffer) { - FILE* file = tmpfile(); - EXPECT_TRUE( file != NULL ); + FILE* file = tmpfile(); + EXPECT_TRUE( file != NULL ); - msgpack::fbuffer fbuf(file); - EXPECT_EQ(file, fbuf.file()); + msgpack::fbuffer fbuf(file); + EXPECT_EQ(file, fbuf.file()); - fbuf.write("a", 1); - fbuf.write("a", 1); - fbuf.write("a", 1); + fbuf.write("a", 1); + fbuf.write("a", 1); + fbuf.write("a", 1); - fflush(file); - rewind(file); - for (size_t i=0; i < 3; ++i) { - int ch = fgetc(file); - EXPECT_TRUE(ch != EOF); - EXPECT_EQ('a', static_cast(ch)); - } - EXPECT_EQ(EOF, fgetc(file)); - fclose(file); + fflush(file); + rewind(file); + for (size_t i=0; i < 3; ++i) { + int ch = fgetc(file); + EXPECT_TRUE(ch != EOF); + EXPECT_EQ('a', static_cast(ch)); + } + EXPECT_EQ(EOF, fgetc(file)); + fclose(file); } TEST(buffer, fbuffer_c) { - FILE* file = tmpfile(); - void* fbuf = (void*)file; + FILE* file = tmpfile(); + void* fbuf = (void*)file; - EXPECT_TRUE( file != NULL ); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + EXPECT_TRUE( file != NULL ); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - fflush(file); - rewind(file); - for (size_t i=0; i < 3; ++i) { - int ch = fgetc(file); - EXPECT_TRUE(ch != EOF); - EXPECT_EQ('a', (char) ch); - } - EXPECT_EQ(EOF, fgetc(file)); - fclose(file); + fflush(file); + rewind(file); + for (size_t i=0; i < 3; ++i) { + int ch = fgetc(file); + EXPECT_TRUE(ch != EOF); + EXPECT_EQ('a', (char) ch); + } + EXPECT_EQ(EOF, fgetc(file)); + fclose(file); } diff --git a/test/cases.cc b/test/cases.cc index eb1286c7..45aace0b 100644 --- a/test/cases.cc +++ b/test/cases.cc @@ -4,35 +4,35 @@ static void feed_file(msgpack::unpacker& pac, const char* path) { - std::ifstream fin(path); - while(true) { - pac.reserve_buffer(32*1024); - fin.read(pac.buffer(), pac.buffer_capacity()); - if(fin.bad()) { - throw std::runtime_error("read failed"); - } - pac.buffer_consumed(fin.gcount()); - if(fin.fail()) { - break; - } - } + std::ifstream fin(path); + while(true) { + pac.reserve_buffer(32*1024); + fin.read(pac.buffer(), pac.buffer_capacity()); + if(fin.bad()) { + throw std::runtime_error("read failed"); + } + pac.buffer_consumed(fin.gcount()); + if(fin.fail()) { + break; + } + } } TEST(cases, format) { - msgpack::unpacker pac; - msgpack::unpacker pac_compact; + msgpack::unpacker pac; + msgpack::unpacker pac_compact; - feed_file(pac, "cases.mpac"); - feed_file(pac_compact, "cases_compact.mpac"); + feed_file(pac, "cases.mpac"); + feed_file(pac_compact, "cases_compact.mpac"); - msgpack::unpacked result; - while(pac.next(&result)) { - msgpack::unpacked result_compact; - EXPECT_TRUE( pac_compact.next(&result_compact) ); - EXPECT_EQ(result_compact.get(), result.get()); - } + msgpack::unpacked result; + while(pac.next(&result)) { + msgpack::unpacked result_compact; + EXPECT_TRUE( pac_compact.next(&result_compact) ); + EXPECT_EQ(result_compact.get(), result.get()); + } - EXPECT_FALSE( pac_compact.next(&result) ); + EXPECT_FALSE( pac_compact.next(&result) ); } diff --git a/test/convert.cc b/test/convert.cc index 4572580f..dcda77c6 100644 --- a/test/convert.cc +++ b/test/convert.cc @@ -3,74 +3,74 @@ class compatibility { public: - compatibility() : str1("default"), str2("default") { } + compatibility() : str1("default"), str2("default") { } - std::string str1; - std::string str2; + std::string str1; + std::string str2; - MSGPACK_DEFINE(str1, str2); + MSGPACK_DEFINE(str1, str2); }; TEST(convert, compatibility_less) { - std::vector src(1); - src[0] = "kumofs"; + std::vector src(1); + src[0] = "kumofs"; - msgpack::zone z; - msgpack::object obj(src, &z); + msgpack::zone z; + msgpack::object obj(src, &z); - compatibility c; - EXPECT_NO_THROW( obj.convert(&c) ); + compatibility c; + EXPECT_NO_THROW( obj.convert(&c) ); - EXPECT_EQ("kumofs", c.str1); - EXPECT_EQ("default", c.str2); + EXPECT_EQ("kumofs", c.str1); + EXPECT_EQ("default", c.str2); } TEST(convert, compatibility_more) { - std::vector src(3); - src[0] = "kumofs"; - src[1] = "mpio"; - src[2] = "cloudy"; + std::vector src(3); + src[0] = "kumofs"; + src[1] = "mpio"; + src[2] = "cloudy"; - msgpack::zone z; - msgpack::object obj(src, &z); + msgpack::zone z; + msgpack::object obj(src, &z); - compatibility to; - EXPECT_NO_THROW( obj.convert(&to) ); + compatibility to; + EXPECT_NO_THROW( obj.convert(&to) ); - EXPECT_EQ("kumofs", to.str1); - EXPECT_EQ("mpio", to.str2); + EXPECT_EQ("kumofs", to.str1); + EXPECT_EQ("mpio", to.str2); } class enum_member { public: - enum_member() : flag(A) { } + enum_member() : flag(A) { } - enum flags_t { - A = 0, - B = 1 - }; + enum flags_t { + A = 0, + B = 1 + }; - flags_t flag; + flags_t flag; - MSGPACK_DEFINE(flag); + MSGPACK_DEFINE(flag); }; MSGPACK_ADD_ENUM(enum_member::flags_t); TEST(convert, enum_member) { - enum_member src; - src.flag = enum_member::B; + enum_member src; + src.flag = enum_member::B; - msgpack::zone z; - msgpack::object obj(src, &z); + msgpack::zone z; + msgpack::object obj(src, &z); - enum_member to; - EXPECT_NO_THROW( obj.convert(&to) ); + enum_member to; + EXPECT_NO_THROW( obj.convert(&to) ); - EXPECT_EQ(enum_member::B, to.flag); + EXPECT_EQ(enum_member::B, to.flag); } diff --git a/test/fixint.cc b/test/fixint.cc index 63288a1b..cf109ae5 100644 --- a/test/fixint.cc +++ b/test/fixint.cc @@ -3,53 +3,53 @@ template void check_size(size_t size) { - T v(0); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, v); - EXPECT_EQ(size, sbuf.size()); + T v(0); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, v); + EXPECT_EQ(size, sbuf.size()); } TEST(fixint, size) { - check_size(2); - check_size(3); - check_size(5); - check_size(9); + check_size(2); + check_size(3); + check_size(5); + check_size(9); - check_size(2); - check_size(3); - check_size(5); - check_size(9); + check_size(2); + check_size(3); + check_size(5); + check_size(9); } template void check_convert() { - T v1(-11); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, v1); + T v1(-11); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, v1); - msgpack::unpacked msg; - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + msgpack::unpacked msg; + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); - T v2; - msg.get().convert(&v2); + T v2; + msg.get().convert(&v2); - EXPECT_EQ(v1.get(), v2.get()); + EXPECT_EQ(v1.get(), v2.get()); - EXPECT_EQ(msg.get(), msgpack::object(T(v1.get()))); + EXPECT_EQ(msg.get(), msgpack::object(T(v1.get()))); } TEST(fixint, convert) { - check_convert(); - check_convert(); - check_convert(); - check_convert(); + check_convert(); + check_convert(); + check_convert(); + check_convert(); - check_convert(); - check_convert(); - check_convert(); - check_convert(); + check_convert(); + check_convert(); + check_convert(); + check_convert(); } diff --git a/test/fixint_c.cc b/test/fixint_c.cc index 7cd05261..d9dc5180 100644 --- a/test/fixint_c.cc +++ b/test/fixint_c.cc @@ -3,30 +3,30 @@ TEST(fixint, size) { - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - size_t sum = 0; + size_t sum = 0; - EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0)); + EXPECT_EQ(sum+=2, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0)); + EXPECT_EQ(sum+=3, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0)); + EXPECT_EQ(sum+=5, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0)); + EXPECT_EQ(sum+=9, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0)); + EXPECT_EQ(sum+=2, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0)); + EXPECT_EQ(sum+=3, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0)); + EXPECT_EQ(sum+=5, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0)); + EXPECT_EQ(sum+=9, sbuf->size); - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); } diff --git a/test/msgpack_tuple.cc b/test/msgpack_tuple.cc index 2b11a83e..9779d06a 100644 --- a/test/msgpack_tuple.cc +++ b/test/msgpack_tuple.cc @@ -4,100 +4,100 @@ TEST(msgpack_tuple, member_get) { - msgpack::type::tuple t1(42, true, "ABC"); - EXPECT_EQ(42, t1.get<0>()); - EXPECT_EQ(true, t1.get<1>()); - EXPECT_EQ("ABC", t1.get<2>()); - t1.get<0>() = 40; - t1.get<1>() = false; - t1.get<2>() = "DEFG"; - EXPECT_EQ(40, t1.get<0>()); - EXPECT_EQ(false, t1.get<1>()); - EXPECT_EQ("DEFG", t1.get<2>()); + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); } TEST(msgpack_tuple, non_member_get) { - msgpack::type::tuple t1(42, true, "ABC"); - EXPECT_EQ(42, msgpack::type::get<0>(t1)); - EXPECT_EQ(true, msgpack::type::get<1>(t1)); - EXPECT_EQ("ABC", msgpack::type::get<2>(t1)); - msgpack::type::get<0>(t1) = 40; - msgpack::type::get<1>(t1) = false; - msgpack::type::get<2>(t1) = "DEFG"; - EXPECT_EQ(40, msgpack::type::get<0>(t1)); - EXPECT_EQ(false, msgpack::type::get<1>(t1)); - EXPECT_EQ("DEFG", msgpack::type::get<2>(t1)); + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, msgpack::type::get<0>(t1)); + EXPECT_EQ(true, msgpack::type::get<1>(t1)); + EXPECT_EQ("ABC", msgpack::type::get<2>(t1)); + msgpack::type::get<0>(t1) = 40; + msgpack::type::get<1>(t1) = false; + msgpack::type::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, msgpack::type::get<0>(t1)); + EXPECT_EQ(false, msgpack::type::get<1>(t1)); + EXPECT_EQ("DEFG", msgpack::type::get<2>(t1)); } #if __cplusplus >= 201103 TEST(msgpack_tuple, std_non_member_get) { - msgpack::type::tuple t1(42, true, "ABC"); - EXPECT_EQ(42, std::get<0>(t1)); - EXPECT_EQ(true, std::get<1>(t1)); - EXPECT_EQ("ABC", std::get<2>(t1)); - std::get<0>(t1) = 40; - std::get<1>(t1) = false; - std::get<2>(t1) = "DEFG"; - EXPECT_EQ(40, std::get<0>(t1)); - EXPECT_EQ(false, std::get<1>(t1)); - EXPECT_EQ("DEFG", std::get<2>(t1)); + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, std::get<0>(t1)); + EXPECT_EQ(true, std::get<1>(t1)); + EXPECT_EQ("ABC", std::get<2>(t1)); + std::get<0>(t1) = 40; + std::get<1>(t1) = false; + std::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, std::get<0>(t1)); + EXPECT_EQ(false, std::get<1>(t1)); + EXPECT_EQ("DEFG", std::get<2>(t1)); } TEST(msgpack_tuple, make_tuple) { - msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); - EXPECT_EQ(42, t1.get<0>()); - EXPECT_EQ(true, t1.get<1>()); - EXPECT_EQ("ABC", t1.get<2>()); - t1.get<0>() = 40; - t1.get<1>() = false; - t1.get<2>() = "DEFG"; - EXPECT_EQ(40, t1.get<0>()); - EXPECT_EQ(false, t1.get<1>()); - EXPECT_EQ("DEFG", t1.get<2>()); + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); } TEST(msgpack_tuple, std_make_tuple) { - msgpack::type::tuple t1 = std::make_tuple(42, true, "ABC"); - EXPECT_EQ(42, t1.get<0>()); - EXPECT_EQ(true, t1.get<1>()); - EXPECT_EQ("ABC", t1.get<2>()); + msgpack::type::tuple t1 = std::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); } TEST(msgpack_tuple, tie) { - int i(43); - bool b(false); - std::string s("DEFG"); - msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC"); - EXPECT_EQ(42, i); - EXPECT_EQ(true, b); - EXPECT_EQ("ABC", s); + int i(43); + bool b(false); + std::string s("DEFG"); + msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, i); + EXPECT_EQ(true, b); + EXPECT_EQ("ABC", s); } TEST(msgpack_tuple, tuple_cat) { - msgpack::type::tuple t1 = msgpack::type::make_tuple(42); - msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); - msgpack::type::tuple t3 = msgpack::type::tuple_cat(t1, std::move(t2)); - EXPECT_EQ(42, t3.get<0>()); - EXPECT_EQ(true, t3.get<1>()); - EXPECT_EQ("ABC", t3.get<2>()); + msgpack::type::tuple t1 = msgpack::type::make_tuple(42); + msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); + msgpack::type::tuple t3 = msgpack::type::tuple_cat(t1, std::move(t2)); + EXPECT_EQ(42, t3.get<0>()); + EXPECT_EQ(true, t3.get<1>()); + EXPECT_EQ("ABC", t3.get<2>()); } TEST(msgpack_tuple, swap) { - msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); - msgpack::type::tuple t2 = msgpack::type::make_tuple(40, false, "DEFG"); - msgpack::type::swap(t1, t2); - EXPECT_EQ(42, t2.get<0>()); - EXPECT_EQ(true, t2.get<1>()); - EXPECT_EQ("ABC", t2.get<2>()); - EXPECT_EQ(40, t1.get<0>()); - EXPECT_EQ(false, t1.get<1>()); - EXPECT_EQ("DEFG", t1.get<2>()); + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + msgpack::type::tuple t2 = msgpack::type::make_tuple(40, false, "DEFG"); + msgpack::type::swap(t1, t2); + EXPECT_EQ(42, t2.get<0>()); + EXPECT_EQ(true, t2.get<1>()); + EXPECT_EQ("ABC", t2.get<2>()); + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); } #endif diff --git a/test/msgpackc_test.cpp b/test/msgpackc_test.cpp index e8d00bed..9c1977b0 100644 --- a/test/msgpackc_test.cpp +++ b/test/msgpackc_test.cpp @@ -80,9 +80,9 @@ TEST(MSGPACKC, simple_buffer_char) { #if defined(CHAR_MIN) #if CHAR_MIN < 0 - GEN_TEST_SIGNED(char, char); + GEN_TEST_SIGNED(char, char); #else - GEN_TEST_UNSIGNED(char, char); + GEN_TEST_UNSIGNED(char, char); #endif #else #error CHAR_MIN is not defined @@ -490,7 +490,7 @@ TEST(MSGPACKC, unpack_str16) { size_t str_size = 7; const char buf[] = { - (char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + (char)0xda, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; msgpack_zone z; @@ -510,7 +510,7 @@ TEST(MSGPACKC, unpack_str32) { size_t str_size = 7; const char buf[] = { - (char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' + (char)0xdb, 0, 0, 0, 7, 'f', 'r', 's', 'y', 'u', 'k', 'i' }; msgpack_zone z; diff --git a/test/object.cc b/test/object.cc index 7a6b0a87..627ca1a1 100644 --- a/test/object.cc +++ b/test/object.cc @@ -2,133 +2,133 @@ #include struct myclass { - myclass() : num(0), str("default") { } + myclass() : num(0), str("default") { } - myclass(int num, const std::string& str) : - num(0), str("default") { } + myclass(int num, const std::string& str) : + num(0), str("default") { } - ~myclass() { } + ~myclass() { } - int num; - std::string str; + int num; + std::string str; - MSGPACK_DEFINE(num, str); + MSGPACK_DEFINE(num, str); - bool operator==(const myclass& o) const - { - return num == o.num && str == o.str; - } + bool operator==(const myclass& o) const + { + return num == o.num && str == o.str; + } }; std::ostream& operator<<(std::ostream& o, const myclass& m) { - return o << "myclass("<()); + EXPECT_EQ(m1, obj.as()); } TEST(object, print) { - msgpack::object obj; - std::cout << obj << std::endl; + msgpack::object obj; + std::cout << obj << std::endl; } TEST(object, is_nil) { - msgpack::object obj; - EXPECT_TRUE(obj.is_nil()); + msgpack::object obj; + EXPECT_TRUE(obj.is_nil()); } TEST(object, type_error) { - msgpack::object obj(1); - EXPECT_THROW(obj.as(), msgpack::type_error); - EXPECT_THROW(obj.as >(), msgpack::type_error); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1u, obj.as()); - EXPECT_EQ(1u, obj.as()); + msgpack::object obj(1); + EXPECT_THROW(obj.as(), msgpack::type_error); + EXPECT_THROW(obj.as >(), msgpack::type_error); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1u, obj.as()); + EXPECT_EQ(1u, obj.as()); } TEST(object, equal_primitive) { - msgpack::object obj_nil; - EXPECT_EQ(obj_nil, msgpack::object()); + msgpack::object obj_nil; + EXPECT_EQ(obj_nil, msgpack::object()); - msgpack::object obj_int(1); - EXPECT_EQ(obj_int, msgpack::object(1)); - EXPECT_EQ(obj_int, 1); + msgpack::object obj_int(1); + EXPECT_EQ(obj_int, msgpack::object(1)); + EXPECT_EQ(obj_int, 1); - msgpack::object obj_double(1.2); - EXPECT_EQ(obj_double, msgpack::object(1.2)); - EXPECT_EQ(obj_double, 1.2); + msgpack::object obj_double(1.2); + EXPECT_EQ(obj_double, msgpack::object(1.2)); + EXPECT_EQ(obj_double, 1.2); - msgpack::object obj_bool(true); - EXPECT_EQ(obj_bool, msgpack::object(true)); - EXPECT_EQ(obj_bool, true); + msgpack::object obj_bool(true); + EXPECT_EQ(obj_bool, msgpack::object(true)); + EXPECT_EQ(obj_bool, true); } TEST(object, construct_primitive) { - msgpack::object obj_nil; - EXPECT_EQ(msgpack::type::NIL, obj_nil.type); + msgpack::object obj_nil; + EXPECT_EQ(msgpack::type::NIL, obj_nil.type); - msgpack::object obj_uint(1); - EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type); - EXPECT_EQ(1u, obj_uint.via.u64); + msgpack::object obj_uint(1); + EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type); + EXPECT_EQ(1u, obj_uint.via.u64); - msgpack::object obj_int(-1); - EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type); - EXPECT_EQ(-1, obj_int.via.i64); + msgpack::object obj_int(-1); + EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type); + EXPECT_EQ(-1, obj_int.via.i64); - msgpack::object obj_double(1.2); - EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type); - EXPECT_EQ(1.2, obj_double.via.dec); + msgpack::object obj_double(1.2); + EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type); + EXPECT_EQ(1.2, obj_double.via.dec); - msgpack::object obj_bool(true); - EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type); - EXPECT_EQ(true, obj_bool.via.boolean); + msgpack::object obj_bool(true); + EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type); + EXPECT_EQ(true, obj_bool.via.boolean); } diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index 6718a01b..3805a4a6 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -4,120 +4,120 @@ TEST(pack, num) { - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); } TEST(pack, vector) { - msgpack::sbuffer sbuf; - std::vector vec; - vec.push_back(1); - vec.push_back(2); - vec.push_back(3); - msgpack::pack(sbuf, vec); + msgpack::sbuffer sbuf; + std::vector vec; + vec.push_back(1); + vec.push_back(2); + vec.push_back(3); + msgpack::pack(sbuf, vec); } TEST(pack, to_ostream) { - std::ostringstream stream; - msgpack::pack(stream, 1); + std::ostringstream stream; + msgpack::pack(stream, 1); } struct myclass { - myclass() : num(0), str("default") { } + myclass() : num(0), str("default") { } - myclass(int num, const std::string& str) : - num(num), str(str) { } + myclass(int num, const std::string& str) : + num(num), str(str) { } - ~myclass() { } + ~myclass() { } - int num; - std::string str; + int num; + std::string str; - MSGPACK_DEFINE(num, str); + MSGPACK_DEFINE(num, str); }; TEST(pack, myclass) { - msgpack::sbuffer sbuf; - myclass m(1, "msgpack"); - msgpack::pack(sbuf, m); + msgpack::sbuffer sbuf; + myclass m(1, "msgpack"); + msgpack::pack(sbuf, m); } TEST(unpack, myclass) { - msgpack::sbuffer sbuf; - myclass m1(1, "phraser"); - msgpack::pack(sbuf, m1); + msgpack::sbuffer sbuf; + myclass m1(1, "phraser"); + msgpack::pack(sbuf, m1); - msgpack::zone z; - msgpack::object obj; + msgpack::zone z; + msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack_return ret = + msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - myclass m2 = obj.as(); - EXPECT_EQ(m1.num, m2.num); - EXPECT_EQ(m1.str, m2.str); + myclass m2 = obj.as(); + EXPECT_EQ(m1.num, m2.num); + EXPECT_EQ(m1.str, m2.str); } TEST(unpack, sequence) { - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::pack(sbuf, 2); - msgpack::pack(sbuf, 3); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::pack(sbuf, 2); + msgpack::pack(sbuf, 3); - size_t offset = 0; + size_t offset = 0; - msgpack::unpacked msg; + msgpack::unpacked msg; - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); - EXPECT_EQ(1, msg.get().as()); + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + EXPECT_EQ(1, msg.get().as()); - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); - EXPECT_EQ(2, msg.get().as()); + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + EXPECT_EQ(2, msg.get().as()); - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); - EXPECT_EQ(3, msg.get().as()); + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + EXPECT_EQ(3, msg.get().as()); } TEST(unpack, sequence_compat) { - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::pack(sbuf, 2); - msgpack::pack(sbuf, 3); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::pack(sbuf, 2); + msgpack::pack(sbuf, 3); - size_t offset = 0; + size_t offset = 0; - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret; + msgpack::zone z; + msgpack::object obj; + msgpack::unpack_return ret; - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); - EXPECT_EQ(1, obj.as()); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + EXPECT_TRUE(ret >= 0); + EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); + EXPECT_EQ(1, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); - EXPECT_EQ(2, obj.as()); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + EXPECT_TRUE(ret >= 0); + EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); + EXPECT_EQ(2, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - EXPECT_EQ(3, obj.as()); + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + EXPECT_TRUE(ret >= 0); + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + EXPECT_EQ(3, obj.as()); } diff --git a/test/pack_unpack_c.cc b/test/pack_unpack_c.cc index e9a03892..60e0e00e 100644 --- a/test/pack_unpack_c.cc +++ b/test/pack_unpack_c.cc @@ -4,67 +4,67 @@ TEST(pack, num) { - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); } TEST(pack, array) { - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - EXPECT_EQ(0, msgpack_pack_array(pk, 3)); - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 3)); + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); } TEST(unpack, sequence) { - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - msgpack_packer_free(pk); + msgpack_packer_free(pk); - bool success; - size_t offset = 0; + bool success; + size_t offset = 0; - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); + msgpack_unpacked msg; + msgpack_unpacked_init(&msg); - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(1, msg.data.via.u64); + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(1, msg.data.via.u64); - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(2, msg.data.via.u64); + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(2, msg.data.via.u64); - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(3, msg.data.via.u64); + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(3, msg.data.via.u64); - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_FALSE(success); + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_FALSE(success); - msgpack_sbuffer_free(sbuf); - msgpack_unpacked_destroy(&msg); + msgpack_sbuffer_free(sbuf); + msgpack_unpacked_destroy(&msg); } diff --git a/test/streaming.cc b/test/streaming.cc index 551cf842..e10b0f93 100644 --- a/test/streaming.cc +++ b/test/streaming.cc @@ -4,217 +4,217 @@ TEST(streaming, basic) { - msgpack::sbuffer buffer; + msgpack::sbuffer buffer; - msgpack::packer pk(&buffer); - pk.pack(1); - pk.pack(2); - pk.pack(3); + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); - const char* input = buffer.data(); - const char* const eof = input + buffer.size(); + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); - msgpack::unpacker pac; - msgpack::unpacked result; + msgpack::unpacker pac; + msgpack::unpacked result; - int count = 0; - while(count < 3) { - pac.reserve_buffer(32*1024); + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); - // read buffer into pac.buffer() upto - // pac.buffer_capacity() bytes. - size_t len = 1; - memcpy(pac.buffer(), input, len); - input += len; + // read buffer into pac.buffer() upto + // pac.buffer_capacity() bytes. + size_t len = 1; + memcpy(pac.buffer(), input, len); + input += len; - pac.buffer_consumed(len); + pac.buffer_consumed(len); - while(pac.next(&result)) { - msgpack::object obj = result.get(); - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } - } + while(pac.next(&result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } - EXPECT_TRUE(input < eof); - } + EXPECT_TRUE(input < eof); + } } class event_handler { public: - event_handler(std::istream& input) : input(input) { } - ~event_handler() { } + event_handler(std::istream& input) : input(input) { } + ~event_handler() { } - void on_read() - { - while(true) { - pac.reserve_buffer(32*1024); + void on_read() + { + while(true) { + pac.reserve_buffer(32*1024); - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - if(len == 0) { - return; - } + if(len == 0) { + return; + } - pac.buffer_consumed(len); + pac.buffer_consumed(len); - msgpack::unpacked result; - while(pac.next(&result)) { - on_message(result.get(), msgpack::move(result.zone())); - } + msgpack::unpacked result; + while(pac.next(&result)) { + on_message(result.get(), msgpack::move(result.zone())); + } - if(pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } - } + if(pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } + } - void on_message(msgpack::object obj, msgpack::unique_ptr z) - { - EXPECT_EQ(expect, obj.as()); - } + void on_message(msgpack::object obj, msgpack::unique_ptr z) + { + EXPECT_EQ(expect, obj.as()); + } - int expect; + int expect; private: - std::istream& input; - msgpack::unpacker pac; + std::istream& input; + msgpack::unpacker pac; }; TEST(streaming, event) { - std::stringstream stream; - msgpack::packer pk(&stream); + std::stringstream stream; + msgpack::packer pk(&stream); - event_handler handler(stream); + event_handler handler(stream); - pk.pack(1); - handler.expect = 1; - handler.on_read(); + pk.pack(1); + handler.expect = 1; + handler.on_read(); - pk.pack(2); - handler.expect = 2; - handler.on_read(); + pk.pack(2); + handler.expect = 2; + handler.on_read(); - pk.pack(3); - handler.expect = 3; - handler.on_read(); + pk.pack(3); + handler.expect = 3; + handler.on_read(); } // backward compatibility TEST(streaming, basic_compat) { - std::ostringstream stream; - msgpack::packer pk(&stream); + std::ostringstream stream; + msgpack::packer pk(&stream); - pk.pack(1); - pk.pack(2); - pk.pack(3); + pk.pack(1); + pk.pack(2); + pk.pack(3); - std::istringstream input(stream.str()); + std::istringstream input(stream.str()); - msgpack::unpacker pac; + msgpack::unpacker pac; - int count = 0; - while(count < 3) { - pac.reserve_buffer(32*1024); + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - pac.buffer_consumed(len); + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + pac.buffer_consumed(len); - while(pac.execute()) { - msgpack::unique_ptr z(pac.release_zone()); - msgpack::object obj = pac.data(); - pac.reset(); + while(pac.execute()) { + msgpack::unique_ptr z(pac.release_zone()); + msgpack::object obj = pac.data(); + pac.reset(); - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } - } - } + } + } } // backward compatibility class event_handler_compat { public: - event_handler_compat(std::istream& input) : input(input) { } - ~event_handler_compat() { } + event_handler_compat(std::istream& input) : input(input) { } + ~event_handler_compat() { } - void on_read() - { - while(true) { - pac.reserve_buffer(32*1024); + void on_read() + { + while(true) { + pac.reserve_buffer(32*1024); - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - if(len == 0) { - return; - } + if(len == 0) { + return; + } - pac.buffer_consumed(len); + pac.buffer_consumed(len); - while(pac.execute()) { - msgpack::unique_ptr z(pac.release_zone()); - msgpack::object obj = pac.data(); - pac.reset(); - on_message(obj, msgpack::move(z)); - } + while(pac.execute()) { + msgpack::unique_ptr z(pac.release_zone()); + msgpack::object obj = pac.data(); + pac.reset(); + on_message(obj, msgpack::move(z)); + } - if(pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } - } + if(pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } + } - void on_message(msgpack::object obj, msgpack::unique_ptr z) - { - EXPECT_EQ(expect, obj.as()); - } + void on_message(msgpack::object obj, msgpack::unique_ptr z) + { + EXPECT_EQ(expect, obj.as()); + } - int expect; + int expect; private: - std::istream& input; - msgpack::unpacker pac; + std::istream& input; + msgpack::unpacker pac; }; TEST(streaming, event_compat) { - std::stringstream stream; - msgpack::packer pk(&stream); + std::stringstream stream; + msgpack::packer pk(&stream); - event_handler_compat handler(stream); + event_handler_compat handler(stream); - pk.pack(1); - handler.expect = 1; - handler.on_read(); + pk.pack(1); + handler.expect = 1; + handler.on_read(); - pk.pack(2); - handler.expect = 2; - handler.on_read(); + pk.pack(2); + handler.expect = 2; + handler.on_read(); - pk.pack(3); - handler.expect = 3; - handler.on_read(); + pk.pack(3); + handler.expect = 3; + handler.on_read(); } diff --git a/test/streaming_c.cc b/test/streaming_c.cc index bfd9f714..87708b5a 100644 --- a/test/streaming_c.cc +++ b/test/streaming_c.cc @@ -4,111 +4,111 @@ TEST(streaming, basic) { - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); + msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); + msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - EXPECT_EQ(0, msgpack_pack_str(pk, 3)); - EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); - EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_str(pk, 8)); - EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); - EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); - EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); - EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); - EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); - EXPECT_EQ(0, msgpack_pack_map(pk, 1)); - EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); - EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); - int max_count = 6; + // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + EXPECT_EQ(0, msgpack_pack_str(pk, 3)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 1)); + EXPECT_EQ(0, msgpack_pack_str(pk, 8)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 1)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); + EXPECT_EQ(0, msgpack_pack_map(pk, 1)); + EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); + EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); + int max_count = 6; - msgpack_packer_free(pk); + msgpack_packer_free(pk); - const char* input = buffer->data; - const char* const eof = input + buffer->size; + const char* input = buffer->data; + const char* const eof = input + buffer->size; - msgpack_unpacker pac; - msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + msgpack_unpacker pac; + msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); - msgpack_unpacked result; - msgpack_unpacked_init(&result); + msgpack_unpacked result; + msgpack_unpacked_init(&result); - int count = 0; - while(count < max_count) { - bool unpacked = false; + int count = 0; + while(count < max_count) { + bool unpacked = false; - msgpack_unpacker_reserve_buffer(&pac, 32*1024); + msgpack_unpacker_reserve_buffer(&pac, 32*1024); - while(!unpacked) { - /* read buffer into msgpack_unapcker_buffer(&pac) upto - * msgpack_unpacker_buffer_capacity(&pac) bytes. */ - memcpy(msgpack_unpacker_buffer(&pac), input, 1); - input += 1; + while(!unpacked) { + /* read buffer into msgpack_unapcker_buffer(&pac) upto + * msgpack_unpacker_buffer_capacity(&pac) bytes. */ + memcpy(msgpack_unpacker_buffer(&pac), input, 1); + input += 1; - EXPECT_TRUE(input <= eof); + EXPECT_TRUE(input <= eof); - msgpack_unpacker_buffer_consumed(&pac, 1); + msgpack_unpacker_buffer_consumed(&pac, 1); - while(msgpack_unpacker_next(&pac, &result)) { - unpacked = 1; - msgpack_object obj = result.data; - msgpack_object e; - switch(count++) { - case 0: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(1, obj.via.u64); - break; - case 1: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(2, obj.via.u64); - break; - case 2: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(3, obj.via.u64); - break; - case 3: - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); - break; - case 4: - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1, obj.via.array.size); - e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); - EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); - break; - case 5: - EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); - EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); - break; - case 6: - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1, obj.via.array.size); - e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); - EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); - break; - case 7: - EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); - EXPECT_EQ(1, obj.via.map.size); - e = obj.via.map.ptr[0].key; - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_FLOAT_EQ(0.4, (float)e.via.dec); - e = obj.via.map.ptr[0].val; - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_DOUBLE_EQ(0.8, e.via.dec); - break; - } - } - } - } + while(msgpack_unpacker_next(&pac, &result)) { + unpacked = 1; + msgpack_object obj = result.data; + msgpack_object e; + switch(count++) { + case 0: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(1, obj.via.u64); + break; + case 1: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(2, obj.via.u64); + break; + case 2: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(3, obj.via.u64); + break; + case 3: + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); + break; + case 4: + EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); + EXPECT_EQ(1, obj.via.array.size); + e = obj.via.array.ptr[0]; + EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); + EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); + break; + case 5: + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); + break; + case 6: + EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); + EXPECT_EQ(1, obj.via.array.size); + e = obj.via.array.ptr[0]; + EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); + EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); + break; + case 7: + EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); + EXPECT_EQ(1, obj.via.map.size); + e = obj.via.map.ptr[0].key; + EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); + ASSERT_FLOAT_EQ(0.4, (float)e.via.dec); + e = obj.via.map.ptr[0].val; + EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); + ASSERT_DOUBLE_EQ(0.8, e.via.dec); + break; + } + } + } + } - msgpack_unpacker_destroy(&pac); - msgpack_unpacked_destroy(&result); + msgpack_unpacker_destroy(&pac); + msgpack_unpacked_destroy(&result); } diff --git a/test/version.cc b/test/version.cc index 9357271e..d2809b21 100644 --- a/test/version.cc +++ b/test/version.cc @@ -3,11 +3,11 @@ TEST(version, print) { - printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); - printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); - printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); - printf("msgpack_version() : %s\n", msgpack_version()); - printf("msgpack_version_major() : %d\n", msgpack_version_major()); - printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); + printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); + printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); + printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); + printf("msgpack_version() : %s\n", msgpack_version()); + printf("msgpack_version_major() : %d\n", msgpack_version_major()); + printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); } diff --git a/test/zone.cc b/test/zone.cc index b364e3fb..b2dc543e 100644 --- a/test/zone.cc +++ b/test/zone.cc @@ -3,76 +3,76 @@ TEST(zone, allocate_align) { - msgpack::zone z; - char* buf1 = (char*)z.allocate_align(4); - memcpy(buf1, "test", 4); - char* buf2 = (char*)z.allocate_align(4); - memcpy(buf2, "test", 4); + msgpack::zone z; + char* buf1 = (char*)z.allocate_align(4); + memcpy(buf1, "test", 4); + char* buf2 = (char*)z.allocate_align(4); + memcpy(buf2, "test", 4); } class myclass { public: - myclass() : num(0), str("default") { } + myclass() : num(0), str("default") { } - myclass(int num, const std::string& str) : - num(num), str(str) { } + myclass(int num, const std::string& str) : + num(num), str(str) { } - ~myclass() { } + ~myclass() { } - int num; - std::string str; + int num; + std::string str; private: - myclass(const myclass&); + myclass(const myclass&); }; TEST(zone, allocate) { - msgpack::zone z; - myclass* m = z.allocate(); - EXPECT_EQ(m->num, 0); - EXPECT_EQ(m->str, "default"); + msgpack::zone z; + myclass* m = z.allocate(); + EXPECT_EQ(m->num, 0); + EXPECT_EQ(m->str, "default"); } TEST(zone, allocate_constructor) { - msgpack::zone z; - myclass* m = z.allocate(7, "msgpack"); - EXPECT_EQ(m->num, 7); - EXPECT_EQ(m->str, "msgpack"); + msgpack::zone z; + myclass* m = z.allocate(7, "msgpack"); + EXPECT_EQ(m->num, 7); + EXPECT_EQ(m->str, "msgpack"); } static void custom_finalizer_func(void* user) { - myclass* m = (myclass*)user; - delete m; + myclass* m = (myclass*)user; + delete m; } TEST(zone, push_finalizer) { - msgpack::zone z; - myclass* m = new myclass(); - z.push_finalizer(custom_finalizer_func, (void*)m); + msgpack::zone z; + myclass* m = new myclass(); + z.push_finalizer(custom_finalizer_func, (void*)m); } TEST(zone, push_finalizer_unique_ptr) { - msgpack::zone z; - msgpack::unique_ptr am(new myclass()); - z.push_finalizer(msgpack::move(am)); + msgpack::zone z; + msgpack::unique_ptr am(new myclass()); + z.push_finalizer(msgpack::move(am)); } TEST(zone, allocate_no_align) { - msgpack::zone z; - char* buf1 = (char*)z.allocate_no_align(4); - char* buf2 = (char*)z.allocate_no_align(4); - EXPECT_EQ(buf1+4, buf2); + msgpack::zone z; + char* buf1 = (char*)z.allocate_no_align(4); + char* buf2 = (char*)z.allocate_no_align(4); + EXPECT_EQ(buf1+4, buf2); } From cc571b8bb1b38a7f47077bbd3af092c6526077e3 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 12 Jul 2014 00:21:35 +0900 Subject: [PATCH 079/153] Replaced std::auto_ptr with msgpack::unique_ptr. --- example/stream.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/example/stream.cc b/example/stream.cc index 094e9984..326665cf 100644 --- a/example/stream.cc +++ b/example/stream.cc @@ -13,7 +13,7 @@ public: ~Server() { } - typedef std::auto_ptr auto_zone; + typedef msgpack::unique_ptr auto_zone; void socket_readable() { From aa79fc2ff46dfef45f85f9b00a978090141fee61 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 12 Jul 2014 00:33:06 +0900 Subject: [PATCH 080/153] Updated versions. --- CMakeLists.txt | 6 +++--- include/msgpack/version_master.h | 4 ++-- src/Makefile.am | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f9a1663e..e32d301e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,9 @@ CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6) PROJECT (msgpack) -SET (VERSION 0.5.9) +SET (VERSION 0.6.0) SET (VERSION_MAJOR 0) -SET (VERSION_MINOR 5) +SET (VERSION_MINOR 6) SET (prefix ${CMAKE_INSTALL_PREFIX}) SET (exec_prefix "\${prefix}") @@ -141,7 +141,7 @@ ADD_LIBRARY (msgpack-static STATIC SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack") SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib") -SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 3.0.0) +SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 4.0.0) IF (MSGPACK_BUILD_TESTS) ENABLE_TESTING () diff --git a/include/msgpack/version_master.h b/include/msgpack/version_master.h index 799f4f5e..cabb9718 100644 --- a/include/msgpack/version_master.h +++ b/include/msgpack/version_master.h @@ -1,3 +1,3 @@ #define MSGPACK_VERSION_MAJOR 0 -#define MSGPACK_VERSION_MINOR 5 -#define MSGPACK_VERSION_RELEASE 9 +#define MSGPACK_VERSION_MINOR 6 +#define MSGPACK_VERSION_RELEASE 0 diff --git a/src/Makefile.am b/src/Makefile.am index 106947a7..38b0d120 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -16,7 +16,7 @@ endif # -version-info CURRENT:REVISION:AGE -libmsgpack_la_LDFLAGS = -version-info 3:0:0 -no-undefined +libmsgpack_la_LDFLAGS = -version-info 4:0:0 -no-undefined # backward compatibility From 0e48f65a4b281baca1203a0b12b3bc9349e5d3e6 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 12 Jul 2014 00:41:33 +0900 Subject: [PATCH 081/153] Fixed https://github.com/msgpack/msgpack-c/issues/94 Added a private copy assign operator to unpacker. --- include/msgpack/unpack.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index e2dab058..e1670485 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -864,6 +864,7 @@ private: private: unpacker(const unpacker&); + unpacker& operator=(const unpacker&); }; From 0380215982d7d5ec38cb659f5fdcfc05cbd5399e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 13 Jul 2014 09:35:58 +0900 Subject: [PATCH 082/153] Fixed https://github.com/msgpack/msgpack-c/issues/88 Added examples for the following updated functions: msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result); msgpack_unpack_return msgpack_unpack_next(msgpack_unpacked* result, const char* data, size_t len, size_t* off); --- example/lib_buffer_unpack.c | 119 +++++++++++++++++++++++++++++++++++ example/user_buffer_unpack.c | 75 ++++++++++++++++++++++ include/msgpack/unpack.h | 24 ++++--- src/unpack.c | 44 ++++++++----- test/streaming_c.cc | 2 +- 5 files changed, 236 insertions(+), 28 deletions(-) create mode 100644 example/lib_buffer_unpack.c create mode 100644 example/user_buffer_unpack.c diff --git a/example/lib_buffer_unpack.c b/example/lib_buffer_unpack.c new file mode 100644 index 00000000..1d6fe39e --- /dev/null +++ b/example/lib_buffer_unpack.c @@ -0,0 +1,119 @@ +#include +#include +#include + + +typedef struct receiver { + msgpack_sbuffer sbuf; + size_t rest; +} receiver; + +receiver r; + +size_t receiver_init(receiver *r) { + msgpack_packer pk; + + msgpack_sbuffer_init(&r->sbuf); + msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write); + /* 1st object */ + msgpack_pack_array(&pk, 3); + msgpack_pack_int(&pk, 1); + msgpack_pack_true(&pk); + msgpack_pack_str(&pk, 7); + msgpack_pack_str_body(&pk, "example", 7); + /* 2nd object */ + msgpack_pack_str(&pk, 6); + msgpack_pack_str_body(&pk, "second", 6); + /* 3rd object */ + msgpack_pack_array(&pk, 2); + msgpack_pack_int(&pk, 42); + msgpack_pack_false(&pk); + r->rest = r->sbuf.size; +} + +size_t receiver_recv(receiver *r, char* buf, size_t try_size) { + size_t off = r->sbuf.size - r->rest; + + size_t actual_size = try_size; + if (actual_size > r->rest) actual_size = r->rest; + + memcpy(buf, r->sbuf.data + off, actual_size); + r->rest -= actual_size; + + return actual_size; +} + +#define EACH_RECV_SIZE 4 + +void unpack(receiver* r) { + /* buf is allocated by unpacker. */ + msgpack_unpacker* unp = msgpack_unpacker_new(100); + msgpack_unpacked result; + msgpack_unpack_return ret; + char* buf; + size_t recv_len; + + msgpack_unpacked_init(&result); + if (msgpack_unpacker_buffer_capacity(unp) < EACH_RECV_SIZE) { + bool expanded = msgpack_unpacker_reserve_buffer(unp, 100); + assert(expanded); + } + buf = msgpack_unpacker_buffer(unp); + + recv_len = receiver_recv(r, buf, EACH_RECV_SIZE); + msgpack_unpacker_buffer_consumed(unp, recv_len); + + + int recv_count = 0; + while (recv_len > 0) { + int i = 0; + printf("receive count: %d %d bytes received.:\n", recv_count++, recv_len); + ret = msgpack_unpacker_next(unp, &result); + while (ret == MSGPACK_UNPACK_SUCCESS) { + msgpack_object obj = result.data; + + /* Use obj. */ + printf("Object no %d:\n", i++); + msgpack_object_print(stdout, obj); + printf("\n"); + /* If you want to allocate something on the zone, you can use zone. */ + /* msgpack_zone* zone = result.zone; */ + /* The lifetime of the obj and the zone, */ + + ret = msgpack_unpacker_next(unp, &result); + } + if (ret == MSGPACK_UNPACK_PARSE_ERROR) { + printf("The data in the buf is invalid format.\n"); + msgpack_unpacked_destroy(&result); + return; + } + if (msgpack_unpacker_buffer_capacity(unp) < EACH_RECV_SIZE) { + bool expanded = msgpack_unpacker_reserve_buffer(unp, 100); + assert(expanded); + } + buf = msgpack_unpacker_buffer(unp); + recv_len = receiver_recv(r, buf, 4); + msgpack_unpacker_buffer_consumed(unp, recv_len); + } + msgpack_unpacked_destroy(&result); +} + +int main(void) { + receiver r; + receiver_init(&r); + + unpack(&r); + + return 0; +} + +/* Output */ + +/* +Object no 1: +[1, true, "example"] +Object no 2: +"second" +Object no 3: +[42, false] +*/ diff --git a/example/user_buffer_unpack.c b/example/user_buffer_unpack.c new file mode 100644 index 00000000..d8b25c2a --- /dev/null +++ b/example/user_buffer_unpack.c @@ -0,0 +1,75 @@ +#include +#include +#include + +void prepare(msgpack_sbuffer* sbuf) { + msgpack_packer pk; + + msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write); + /* 1st object */ + msgpack_pack_array(&pk, 3); + msgpack_pack_int(&pk, 1); + msgpack_pack_true(&pk); + msgpack_pack_str(&pk, 7); + msgpack_pack_str_body(&pk, "example", 7); + /* 2nd object */ + msgpack_pack_str(&pk, 6); + msgpack_pack_str_body(&pk, "second", 6); + /* 3rd object */ + msgpack_pack_array(&pk, 2); + msgpack_pack_int(&pk, 42); + msgpack_pack_false(&pk); +} + +void unpack(char const* buf, size_t len) { + /* buf is allocated by client. */ + msgpack_unpacked result; + size_t off = 0; + msgpack_unpack_return ret; + int i = 0; + msgpack_unpacked_init(&result); + ret = msgpack_unpack_next(&result, buf, len, &off); + while (ret == MSGPACK_UNPACK_SUCCESS) { + msgpack_object obj = result.data; + + /* Use obj. */ + printf("Object no %d:\n", i++); + msgpack_object_print(stdout, obj); + printf("\n"); + /* If you want to allocate something on the zone, you can use zone. */ + /* msgpack_zone* zone = result.zone; */ + /* The lifetime of the obj and the zone, */ + + ret = msgpack_unpack_next(&result, buf, len, &off); + } + msgpack_unpacked_destroy(&result); + + if (ret == MSGPACK_UNPACK_CONTINUE) { + printf("All msgpack_object in the buffer is consumed.\n"); + } + else if (ret == MSGPACK_UNPACK_PARSE_ERROR) { + printf("The data in the buf is invalid format.\n"); + } +} + +int main(void) { + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + + prepare(&sbuf); + unpack(sbuf.data, sbuf.size); + + msgpack_sbuffer_destroy(&sbuf); + return 0; +} + +/* Output */ + +/* +Object no 1: +[1, true, "example"] +Object no 2: +"second" +Object no 3: +[42, false] +*/ diff --git a/include/msgpack/unpack.h b/include/msgpack/unpack.h index b5ad757c..66b0b0f6 100644 --- a/include/msgpack/unpack.h +++ b/include/msgpack/unpack.h @@ -38,7 +38,17 @@ typedef struct msgpack_unpacked { msgpack_object data; } msgpack_unpacked; -bool msgpack_unpack_next(msgpack_unpacked* result, +typedef enum { + MSGPACK_UNPACK_SUCCESS = 2, + MSGPACK_UNPACK_EXTRA_BYTES = 1, + MSGPACK_UNPACK_CONTINUE = 0, + MSGPACK_UNPACK_PARSE_ERROR = -1, + MSGPACK_UNPACK_NOMEM_ERROR = -2 +} msgpack_unpack_return; + + +msgpack_unpack_return +msgpack_unpack_next(msgpack_unpacked* result, const char* data, size_t len, size_t* off); /** @} */ @@ -136,7 +146,7 @@ static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, si * Returns true if it successes. Otherwise false is returned. * @param pac pointer to an initialized msgpack_unpacked object. */ -bool msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac); +msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac); /** * Initializes a msgpack_unpacked object. @@ -174,20 +184,14 @@ static inline size_t msgpack_unpacker_message_size(const msgpack_unpacker* mpac) /** @} */ -// obsolete -typedef enum { - MSGPACK_UNPACK_SUCCESS = 2, - MSGPACK_UNPACK_EXTRA_BYTES = 1, - MSGPACK_UNPACK_CONTINUE = 0, - MSGPACK_UNPACK_PARSE_ERROR = -1 -} msgpack_unpack_return; - // obsolete msgpack_unpack_return msgpack_unpack(const char* data, size_t len, size_t* off, msgpack_zone* result_zone, msgpack_object* result); + + static inline size_t msgpack_unpacker_parsed_size(const msgpack_unpacker* mpac); bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac); diff --git a/src/unpack.c b/src/unpack.c index 01661055..8b68efe6 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -390,25 +390,24 @@ void msgpack_unpacker_reset(msgpack_unpacker* mpac) mpac->parsed = 0; } -bool msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) +msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone_free(result->zone); - } - int ret = msgpack_unpacker_execute(mpac); - if(ret <= 0) { + if(ret < 0) { result->zone = NULL; memset(&result->data, 0, sizeof(msgpack_object)); - return false; + return MSGPACK_UNPACK_PARSE_ERROR; } + if(ret == 0) { + return MSGPACK_UNPACK_CONTINUE; + } result->zone = msgpack_unpacker_release_zone(mpac); result->data = msgpack_unpacker_data(mpac); msgpack_unpacker_reset(mpac); - return true; + return MSGPACK_UNPACK_SUCCESS; } @@ -450,7 +449,8 @@ msgpack_unpack(const char* data, size_t len, size_t* off, return MSGPACK_UNPACK_SUCCESS; } -bool msgpack_unpack_next(msgpack_unpacked* result, +msgpack_unpack_return +msgpack_unpack_next(msgpack_unpacked* result, const char* data, size_t len, size_t* off) { msgpack_unpacked_destroy(result); @@ -459,29 +459,39 @@ bool msgpack_unpack_next(msgpack_unpacked* result, if(off != NULL) { noff = *off; } if(len <= noff) { - return false; + return MSGPACK_UNPACK_CONTINUE; } - msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if (!result->zone) { + result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + } + + if (!result->zone) { + return MSGPACK_UNPACK_NOMEM_ERROR; + } template_context ctx; template_init(&ctx); - ctx.user.z = z; + ctx.user.z = result->zone; ctx.user.referenced = false; int e = template_execute(&ctx, data, len, &noff); - if(e <= 0) { - msgpack_zone_free(z); - return false; + if(e < 0) { + msgpack_zone_free(result->zone); + result->zone = NULL; + return MSGPACK_UNPACK_PARSE_ERROR; } if(off != NULL) { *off = noff; } - result->zone = z; + if(e == 0) { + return MSGPACK_UNPACK_CONTINUE; + } + result->data = template_data(&ctx); - return true; + return MSGPACK_UNPACK_SUCCESS; } #if defined(MSGPACK_OLD_COMPILER_BUS_ERROR_WORKAROUND) diff --git a/test/streaming_c.cc b/test/streaming_c.cc index 87708b5a..159eef76 100644 --- a/test/streaming_c.cc +++ b/test/streaming_c.cc @@ -54,7 +54,7 @@ TEST(streaming, basic) msgpack_unpacker_buffer_consumed(&pac, 1); - while(msgpack_unpacker_next(&pac, &result)) { + while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) { unpacked = 1; msgpack_object obj = result.data; msgpack_object e; From 2a694f8c209402487a42ed69e08260f66f7c03a8 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 16 Jul 2014 08:26:36 +0900 Subject: [PATCH 083/153] Fixed markdown format. --- README.md | 140 ++++++++++++++++++++++++------------------------------ 1 file changed, 61 insertions(+), 79 deletions(-) diff --git a/README.md b/README.md index 08606756..83b99e3f 100644 --- a/README.md +++ b/README.md @@ -27,9 +27,7 @@ When you use msgpack on C++03 and C++11, you just add msgpack-c/include to your e.g.) -``` -g++ -I msgpack-c/include your_source_file.cpp -``` + g++ -I msgpack-c/include your_source_file.cpp ### Building and Installing @@ -40,94 +38,79 @@ You will need gcc (4.1.0 or higher), autotools. For C++03 and C: -``` -$ git clone https://github.com/redboltz/msgpack-c/tree/cxx_separate -$ cd msgpack-c -$ ./bootstrap -$ ./configure -$ make -$ sudo make install -``` + $ git clone https://github.com/redboltz/msgpack-c/tree/cxx_separate + $ cd msgpack-c + $ ./bootstrap + $ ./configure + $ make + $ sudo make install For C++11: -``` -$ git clone https://github.com/msgpack/msgpack-c.git -$ cd msgpack-c -$ ./bootstrap -$ ./configure CXXFLAGS="-std=c++11" -$ make -$ sudo make install -``` + $ git clone https://github.com/msgpack/msgpack-c.git + $ cd msgpack-c + $ ./bootstrap + $ ./configure CXXFLAGS="-std=c++11" + $ make + $ sudo make install You need the compiler that fully supports C++11. ##### Using cmake You will need gcc (4.1.0 or higher), cmake. -``` -$ git clone https://github.com/msgpack/msgpack-c.git -$ cd msgpack-c -$ cmake . -$ make -``` + $ git clone https://github.com/msgpack/msgpack-c.git + $ cd msgpack-c + $ cmake . + $ make If you want to setup C++11 version of msgpack, execute the following command: -``` -$ git clone https://github.com/msgpack/msgpack-c.git -$ cd msgpack-c -$ cmake -DMSGPACK_CXX11=ON . -``` + $ git clone https://github.com/msgpack/msgpack-c.git + $ cd msgpack-c + $ cmake -DMSGPACK_CXX11=ON . You need the compiler that fully supports C++11. #### Install from package -Add msgpack-c/src to your include path. -``` - For C++03: -``` -$ wget https://github.com/msgpack/msgpack-c/releases/download/cpp-0.5.9/msgpack-0.5.9.tar.gz -$ tar zxvf msgpack-0.5.9.tar.gz -$ cd msgpack-0.5.9 -$ ./configure + + $ wget https://github.com/msgpack/msgpack-c/releases/download/cpp-0.5.9/msgpack-0.5.9.tar.gz + $ tar zxvf msgpack-0.5.9.tar.gz + $ cd msgpack-0.5.9 + $ ./configure Add msgpack-c/src to your include path. -``` For C: -``` -$ sudo brew install msgpack -``` + + $ sudo brew install msgpack ##### Windows Clone msgpack-c git repository. -``` -$ git clone https://github.com/msgpack/msgpack-c.git -``` + $ git clone https://github.com/msgpack/msgpack-c.git -or using GUI git client. +or using GUI git client. e.g.) tortoise git https://code.google.com/p/tortoisegit/ -Launch cmake GUI client. http://www.cmake.org/cmake/resources/software.html +1. Launch cmake GUI client. http://www.cmake.org/cmake/resources/software.html -Set 'Where is the source code:' text box and 'Where to build the binaries:' text box. +1. Set 'Where is the source code:' text box and 'Where to build the binaries:' text box. -Click 'Configure' button. +1. Click 'Configure' button. -Choose your Visual Studio version. +1. Choose your Visual Studio version. -Click 'Generate' button. +1. Click 'Generate' button. -Open the created msgpack.sln on Visual Studio. +1. Open the created msgpack.sln on Visual Studio. -Build all. +1. Build all. ### Linking with an Application for C @@ -138,35 +121,34 @@ Include `msgpack.h` in your application and link with libmsgpack. Here is a typi When you use the C++ version of the msgpack, you don't need to link any msgpack libraries. ### Code Example -```CPP -#include -#include -#include -#include -int main() { - // This is target object. - std::vector target; - target.push_back("Hello,"); - target.push_back("World!"); + #include + #include + #include + #include - // Serialize it. - msgpack::sbuffer sbuf; // simple buffer - msgpack::pack(&sbuf, target); + int main() { + // This is target object. + std::vector target; + target.push_back("Hello,"); + target.push_back("World!"); - // Deserialize the serialized data. - msgpack::unpacked msg; // includes memory pool and deserialized object - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); - msgpack::object obj = msg.get(); + // Serialize it. + msgpack::sbuffer sbuf; // simple buffer + msgpack::pack(&sbuf, target); - // Print the deserialized object to stdout. - std::cout << obj << std::endl; // ["Hello," "World!"] + // Deserialize the serialized data. + msgpack::unpacked msg; // includes memory pool and deserialized object + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + msgpack::object obj = msg.get(); - // Convert the deserialized object to staticaly typed object. - std::vector result; - obj.convert(&result); + // Print the deserialized object to stdout. + std::cout << obj << std::endl; // ["Hello," "World!"] - // If the type is mismatched, it throws msgpack::type_error. - obj.as(); // type is mismatched, msgpack::type_error is thrown -} -``` + // Convert the deserialized object to staticaly typed object. + std::vector result; + obj.convert(&result); + + // If the type is mismatched, it throws msgpack::type_error. + obj.as(); // type is mismatched, msgpack::type_error is thrown + } From 59b111e026bf4154f2f75271b56d540a96c866b4 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 16 Jul 2014 08:49:27 +0900 Subject: [PATCH 084/153] Removed the contents in 'install from package' section. It is not supported for this branch. Updated the description of the cmake. --- README.md | 35 ++++++++++++----------------------- 1 file changed, 12 insertions(+), 23 deletions(-) diff --git a/README.md b/README.md index 83b99e3f..e3a34f3d 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,8 @@ e.g.) g++ -I msgpack-c/include your_source_file.cpp +If you want to use C version of msgpack, you need to build it. You can also install C and C++ version of msgpack. + ### Building and Installing #### Install from git repository @@ -36,7 +38,8 @@ e.g.) ##### Using autotools You will need gcc (4.1.0 or higher), autotools. -For C++03 and C: +For C: +C++03 and C: $ git clone https://github.com/redboltz/msgpack-c/tree/cxx_separate $ cd msgpack-c @@ -57,38 +60,27 @@ For C++11: You need the compiler that fully supports C++11. ##### Using cmake + +###### CUI + You will need gcc (4.1.0 or higher), cmake. $ git clone https://github.com/msgpack/msgpack-c.git $ cd msgpack-c $ cmake . $ make + $ sudo make install If you want to setup C++11 version of msgpack, execute the following command: $ git clone https://github.com/msgpack/msgpack-c.git $ cd msgpack-c $ cmake -DMSGPACK_CXX11=ON . + $ sudo make install You need the compiler that fully supports C++11. -#### Install from package - -For C++03: - - $ wget https://github.com/msgpack/msgpack-c/releases/download/cpp-0.5.9/msgpack-0.5.9.tar.gz - $ tar zxvf msgpack-0.5.9.tar.gz - $ cd msgpack-0.5.9 - $ ./configure - -Add msgpack-c/src to your include path. - -For C: - - $ sudo brew install msgpack - - -##### Windows +##### GUI on Windows Clone msgpack-c git repository. @@ -112,13 +104,10 @@ e.g.) tortoise git https://code.google.com/p/tortoisegit/ 1. Build all. -### Linking with an Application for C -Include `msgpack.h` in your application and link with libmsgpack. Here is a typical gcc link command: +#### Install from package - gcc myapp.c -lmsgpack -o myapp - -When you use the C++ version of the msgpack, you don't need to link any msgpack libraries. +Install from package for this branch (poc/0.6) is not supported yet. ### Code Example From f11a8111145a6a0d5c6663c1a53c9887f19bf070 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 23 Jul 2014 21:31:42 +0900 Subject: [PATCH 085/153] Added a move constructor and a move assign operator for unpacker and context. https://github.com/msgpack/msgpack-c/issues/96 --- include/msgpack/unpack.hpp | 52 +++++++++++++++++++++++++++++++++++--- test/streaming.cc | 52 +++++++++++++++++++++++++++++++++++++- 2 files changed, 100 insertions(+), 4 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index e1670485..e17a1fee 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -248,6 +248,10 @@ public: { m_stack[0].set_obj(object()); } +#if !defined(MSGPACK_USE_CPP03) + context(context&& other) = default; + context& operator=(context&& other) = default; +#endif // !defined(MSGPACK_USE_CPP03) void init() { @@ -721,6 +725,9 @@ private: unsigned int m_top; unsigned int m_stack_idx; unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE]; +private: + context(context const&); + context& operator=(context const&); }; } // detail @@ -760,6 +767,12 @@ private: class unpacker { public: unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + +#if !defined(MSGPACK_USE_CPP03) + unpacker(unpacker&& other); + unpacker& operator=(unpacker&& other); +#endif // !defined(MSGPACK_USE_CPP03) + ~unpacker(); public: @@ -925,10 +938,44 @@ inline unpacker::unpacker(size_t initial_buffer_size) m_ctx.user().set_referenced(false); } +#if !defined(MSGPACK_USE_CPP03) +// Move constructor and move assignment operator + +inline unpacker::unpacker(unpacker&& other) + :m_buffer(other.m_buffer), + m_used(other.m_used), + m_free(other.m_free), + m_off(other.m_off), + m_parsed(other.m_parsed), + m_z(other.m_z), + m_initial_buffer_size(other.m_initial_buffer_size), + m_ctx(msgpack::move(other.m_ctx)) { + other.m_buffer = nullptr; + other.m_z = nullptr; +} + +inline unpacker& unpacker::operator=(unpacker&& other) { + m_buffer = other.m_buffer; + m_used = other.m_used; + m_free = other.m_free; + m_off = other.m_off; + m_parsed = other.m_parsed; + m_z = other.m_z; + m_initial_buffer_size = other.m_initial_buffer_size; + m_ctx = msgpack::move(other.m_ctx); + other.m_buffer = nullptr; + other.m_z = nullptr; + return *this; +} + +#endif // !defined(MSGPACK_USE_CPP03) + + inline unpacker::~unpacker() { - zone::destroy(m_z); - detail::decl_count(m_buffer); + // These checks are required for move operations. + if (m_z) zone::destroy(m_z); + if (m_buffer) detail::decl_count(m_buffer); } @@ -1269,4 +1316,3 @@ inline object unpack(const char* data, size_t len, zone* z, size_t* off) } // namespace msgpack #endif /* msgpack/unpack.hpp */ - diff --git a/test/streaming.cc b/test/streaming.cc index e10b0f93..c390dc18 100644 --- a/test/streaming.cc +++ b/test/streaming.cc @@ -48,6 +48,57 @@ TEST(streaming, basic) } } +#if !defined(MSGPACK_USE_CPP03) + +TEST(streaming, move) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + + int count = 0; + while(count < 3) { + msgpack::unpacker pac_in(std::move(pac)); + pac_in.reserve_buffer(32*1024); + + // read buffer into pac_in.buffer() upto + // pac_in.buffer_capac_inity() bytes. + size_t len = 1; + memcpy(pac_in.buffer(), input, len); + input += len; + + pac_in.buffer_consumed(len); + + while(pac_in.next(&result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + pac = std::move(pac_in); + } +} + +#endif // !defined(MSGPACK_USE_CPP03) class event_handler { public: @@ -217,4 +268,3 @@ TEST(streaming, event_compat) handler.expect = 3; handler.on_read(); } - From ecdeec99486469c7ae4ebd39483ecd3cf13b9411 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 24 Jul 2014 07:41:23 +0900 Subject: [PATCH 086/153] Fixed the move assign operator implementation. --- include/msgpack/unpack.hpp | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index e17a1fee..8e2a3462 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -955,16 +955,8 @@ inline unpacker::unpacker(unpacker&& other) } inline unpacker& unpacker::operator=(unpacker&& other) { - m_buffer = other.m_buffer; - m_used = other.m_used; - m_free = other.m_free; - m_off = other.m_off; - m_parsed = other.m_parsed; - m_z = other.m_z; - m_initial_buffer_size = other.m_initial_buffer_size; - m_ctx = msgpack::move(other.m_ctx); - other.m_buffer = nullptr; - other.m_z = nullptr; + std::swap(m_z, other.m_z); + std::swap(m_buffer, other.m_buffer); return *this; } From bfa428ab1354780396bf683b5cb8c70c51b23b4e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 24 Jul 2014 07:52:20 +0900 Subject: [PATCH 087/153] Added cpp_config.hpp to install files. --- CMakeLists.txt | 205 ++++++++++++++++++++++++------------------------ src/Makefile.am | 3 +- 2 files changed, 104 insertions(+), 104 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e32d301e..870b7788 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -26,7 +26,7 @@ FIND_PACKAGE (GTest) FIND_PACKAGE (ZLIB) FIND_PACKAGE (Threads) IF (GTEST_FOUND AND ZLIB_FOUND AND THREADS_FOUND) - OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON) + OPTION (MSGPACK_BUILD_TESTS "Build msgpack tests." ON) ENDIF () OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON) @@ -38,105 +38,106 @@ int atomic_sub(int i) { return __gnu_cxx::__exchange_and_add(&i, -1) - 1; } int atomic_add(int i) { return __gnu_cxx::__exchange_and_add(&i, 1) + 1; } int main(int argc, char * argv[]) { - atomic_sub(1); - atomic_add(1); + atomic_sub(1); + atomic_add(1); } " MSGPACK_ENABLE_GCC_CXX_ATOMIC) IF (MSGPACK_ENABLE_GCC_CXX_ATOMIC) - LIST (APPEND msgpack_SOURCES - src/gcc_atomic.cpp - ) + LIST (APPEND msgpack_SOURCES + src/gcc_atomic.cpp + ) ENDIF () LIST (APPEND msgpack_SOURCES - src/unpack.c - src/objectc.c - src/version.c - src/vrefbuffer.c - src/zone.c + src/unpack.c + src/objectc.c + src/version.c + src/vrefbuffer.c + src/zone.c ) LIST (APPEND msgpack_HEADERS - include/msgpack/pack_define.h - include/msgpack/pack_template.h - include/msgpack/unpack_define.h - include/msgpack/unpack_template.h - include/msgpack/sysdep.h - include/msgpack/sbuffer.h - include/msgpack/version.h - include/msgpack/vrefbuffer.h - include/msgpack/zbuffer.h - include/msgpack/fbuffer.h - include/msgpack/pack.h - include/msgpack/unpack.h - include/msgpack/object.h - include/msgpack/zone.h + include/msgpack/pack_define.h + include/msgpack/pack_template.h + include/msgpack/unpack_define.h + include/msgpack/unpack_template.h + include/msgpack/sysdep.h + include/msgpack/sbuffer.h + include/msgpack/version.h + include/msgpack/vrefbuffer.h + include/msgpack/zbuffer.h + include/msgpack/fbuffer.h + include/msgpack/pack.h + include/msgpack/unpack.h + include/msgpack/object.h + include/msgpack/zone.h ) IF (MSGPACK_ENABLE_CXX) - LIST (APPEND msgpack_HEADERS - include/msgpack.hpp - include/msgpack/sbuffer.hpp - include/msgpack/vrefbuffer.hpp - include/msgpack/zbuffer.hpp - include/msgpack/fbuffer.hpp - include/msgpack/pack.hpp - include/msgpack/unpack.hpp - include/msgpack/object.hpp - include/msgpack/zone.hpp - include/msgpack/detail/cpp03_zone.hpp - include/msgpack/detail/cpp11_zone.hpp - include/msgpack/type.hpp - include/msgpack/adaptor/bool.hpp - include/msgpack/adaptor/deque.hpp - include/msgpack/adaptor/float.hpp - include/msgpack/adaptor/fixint.hpp - include/msgpack/adaptor/int.hpp - include/msgpack/adaptor/list.hpp - include/msgpack/adaptor/map.hpp - include/msgpack/adaptor/nil.hpp - include/msgpack/adaptor/pair.hpp - include/msgpack/adaptor/raw.hpp - include/msgpack/adaptor/set.hpp - include/msgpack/adaptor/string.hpp - include/msgpack/adaptor/vector.hpp - include/msgpack/adaptor/msgpack_tuple.hpp - include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp - include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp - include/msgpack/adaptor/define.hpp - include/msgpack/adaptor/detail/cpp03_define.hpp - include/msgpack/adaptor/detail/cpp11_define.hpp - include/msgpack/adaptor/tr1/unordered_map.hpp - include/msgpack/adaptor/tr1/unordered_set.hpp - ) + LIST (APPEND msgpack_HEADERS + include/msgpack.hpp + include/msgpack/cpp_config.hpp + include/msgpack/sbuffer.hpp + include/msgpack/vrefbuffer.hpp + include/msgpack/zbuffer.hpp + include/msgpack/fbuffer.hpp + include/msgpack/pack.hpp + include/msgpack/unpack.hpp + include/msgpack/object.hpp + include/msgpack/zone.hpp + include/msgpack/detail/cpp03_zone.hpp + include/msgpack/detail/cpp11_zone.hpp + include/msgpack/type.hpp + include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/deque.hpp + include/msgpack/adaptor/float.hpp + include/msgpack/adaptor/fixint.hpp + include/msgpack/adaptor/int.hpp + include/msgpack/adaptor/list.hpp + include/msgpack/adaptor/map.hpp + include/msgpack/adaptor/nil.hpp + include/msgpack/adaptor/pair.hpp + include/msgpack/adaptor/raw.hpp + include/msgpack/adaptor/set.hpp + include/msgpack/adaptor/string.hpp + include/msgpack/adaptor/vector.hpp + include/msgpack/adaptor/msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp + include/msgpack/adaptor/define.hpp + include/msgpack/adaptor/detail/cpp03_define.hpp + include/msgpack/adaptor/detail/cpp11_define.hpp + include/msgpack/adaptor/tr1/unordered_map.hpp + include/msgpack/adaptor/tr1/unordered_set.hpp + ) ENDIF () EXECUTE_PROCESS ( - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack + COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/src/msgpack ) CONFIGURE_FILE ( - msgpack.pc.in - msgpack.pc - @ONLY + msgpack.pc.in + msgpack.pc + @ONLY ) INCLUDE_DIRECTORIES ( - ./ - include/ - ${CMAKE_CURRENT_BINARY_DIR}/include/ + ./ + include/ + ${CMAKE_CURRENT_BINARY_DIR}/include/ ) ADD_LIBRARY (msgpack SHARED - ${msgpack_SOURCES} - ${msgpack_HEADERS} + ${msgpack_SOURCES} + ${msgpack_HEADERS} ) ADD_LIBRARY (msgpack-static STATIC - ${msgpack_SOURCES} - ${msgpack_HEADERS} + ${msgpack_SOURCES} + ${msgpack_HEADERS} ) SET_TARGET_PROPERTIES (msgpack-static PROPERTIES OUTPUT_NAME "msgpack") @@ -144,20 +145,20 @@ SET_TARGET_PROPERTIES (msgpack PROPERTIES IMPORT_SUFFIX "_import.lib") SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 4.0.0) IF (MSGPACK_BUILD_TESTS) - ENABLE_TESTING () - ADD_SUBDIRECTORY (test) + ENABLE_TESTING () + ADD_SUBDIRECTORY (test) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3 -DPIC") - SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3" ) + SET_PROPERTY (TARGET msgpack APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3 -DPIC") + SET_PROPERTY (TARGET msgpack-static APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3" ) ENDIF () IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") - IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") - ELSE () - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") - ENDIF () + IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + ENDIF () ENDIF () INSTALL (TARGETS msgpack msgpack-static DESTINATION lib) @@ -167,26 +168,26 @@ INSTALL (FILES msgpack.pc DESTINATION lib/pkgconfig) # Doxygen FIND_PACKAGE (Doxygen) IF (DOXYGEN_FOUND) - ADD_CUSTOM_TARGET ( - doxygen_c - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c - VERBATIM - ) - ADD_CUSTOM_TARGET ( - doxygen_cpp - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp - VERBATIM - ) - ADD_CUSTOM_TARGET ( - doxygen - DEPENDS doxygen_c doxygen_cpp - ) + ADD_CUSTOM_TARGET ( + doxygen_c + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.h" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_c" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_c + VERBATIM + ) + ADD_CUSTOM_TARGET ( + doxygen_cpp + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "FILE_PATTERNS = *.hpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "OUTPUT_DIRECTORY = doc_cpp" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${CMAKE_COMMAND} -E echo "PROJECT_NAME = \"MessagePack for C++\"" >> ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile_cpp + VERBATIM + ) + ADD_CUSTOM_TARGET ( + doxygen + DEPENDS doxygen_c doxygen_cpp + ) ENDIF () diff --git a/src/Makefile.am b/src/Makefile.am index 38b0d120..1d09559c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -1,4 +1,3 @@ - lib_LTLIBRARIES = libmsgpack.la AM_CPPFLAGS = -I../include @@ -53,6 +52,7 @@ nobase_include_HEADERS = \ if ENABLE_CXX nobase_include_HEADERS += \ ../include/msgpack.hpp \ + ../include/msgpack/cpp_config.hpp \ ../include/msgpack/sbuffer.hpp \ ../include/msgpack/vrefbuffer.hpp \ ../include/msgpack/zbuffer.hpp \ @@ -106,4 +106,3 @@ doxygen_cpp: doxygen Doxyfile_cpp doxygen: doxygen_c doxygen_cpp - From 09325ed846b77d7394b0806294e08b6b3abbb85e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 24 Jul 2014 10:08:24 +0900 Subject: [PATCH 088/153] Re-implemented msgpack::unpacker's move operations. I refered to the following article and comments. http://scottmeyers.blogspot.jp/2014/06/the-drawbacks-of-implementing-move.html msgpack::detail::context back to copiable. msgpack::detail::context doen't have any resource ownership, so there is no strong reason to avoid copy. --- include/msgpack/unpack.hpp | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 8e2a3462..4c741a21 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -248,10 +248,6 @@ public: { m_stack[0].set_obj(object()); } -#if !defined(MSGPACK_USE_CPP03) - context(context&& other) = default; - context& operator=(context&& other) = default; -#endif // !defined(MSGPACK_USE_CPP03) void init() { @@ -725,9 +721,6 @@ private: unsigned int m_top; unsigned int m_stack_idx; unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE]; -private: - context(context const&); - context& operator=(context const&); }; } // detail @@ -949,14 +942,14 @@ inline unpacker::unpacker(unpacker&& other) m_parsed(other.m_parsed), m_z(other.m_z), m_initial_buffer_size(other.m_initial_buffer_size), - m_ctx(msgpack::move(other.m_ctx)) { + m_ctx(other.m_ctx) { other.m_buffer = nullptr; other.m_z = nullptr; } inline unpacker& unpacker::operator=(unpacker&& other) { - std::swap(m_z, other.m_z); - std::swap(m_buffer, other.m_buffer); + this->~unpacker(); + new (this) unpacker(std::move(other)); return *this; } From 47f4ffe9f374fb9b52f6a924c0af78fa53f58af3 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 24 Jul 2014 10:54:54 +0900 Subject: [PATCH 089/153] Added cpp11 include files to install files. Sorted C++ install files to avoid overlooking. --- CMakeLists.txt | 41 +++++++++++++++++++++-------------------- src/Makefile.am | 41 ++++++++++++++++++++++------------------- 2 files changed, 43 insertions(+), 39 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 870b7788..f83836b2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -78,39 +78,40 @@ LIST (APPEND msgpack_HEADERS IF (MSGPACK_ENABLE_CXX) LIST (APPEND msgpack_HEADERS include/msgpack.hpp - include/msgpack/cpp_config.hpp - include/msgpack/sbuffer.hpp - include/msgpack/vrefbuffer.hpp - include/msgpack/zbuffer.hpp - include/msgpack/fbuffer.hpp - include/msgpack/pack.hpp - include/msgpack/unpack.hpp - include/msgpack/object.hpp - include/msgpack/zone.hpp - include/msgpack/detail/cpp03_zone.hpp - include/msgpack/detail/cpp11_zone.hpp - include/msgpack/type.hpp include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/cpp11/tuple.hpp + include/msgpack/adaptor/define.hpp include/msgpack/adaptor/deque.hpp - include/msgpack/adaptor/float.hpp + include/msgpack/adaptor/detail/cpp03_define.hpp + include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp11_define.hpp + include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp include/msgpack/adaptor/fixint.hpp + include/msgpack/adaptor/float.hpp include/msgpack/adaptor/int.hpp include/msgpack/adaptor/list.hpp include/msgpack/adaptor/map.hpp + include/msgpack/adaptor/msgpack_tuple.hpp include/msgpack/adaptor/nil.hpp include/msgpack/adaptor/pair.hpp include/msgpack/adaptor/raw.hpp include/msgpack/adaptor/set.hpp include/msgpack/adaptor/string.hpp - include/msgpack/adaptor/vector.hpp - include/msgpack/adaptor/msgpack_tuple.hpp - include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp - include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp - include/msgpack/adaptor/define.hpp - include/msgpack/adaptor/detail/cpp03_define.hpp - include/msgpack/adaptor/detail/cpp11_define.hpp include/msgpack/adaptor/tr1/unordered_map.hpp include/msgpack/adaptor/tr1/unordered_set.hpp + include/msgpack/adaptor/vector.hpp + include/msgpack/cpp_config.hpp + include/msgpack/detail/cpp03_zone.hpp + include/msgpack/detail/cpp11_zone.hpp + include/msgpack/fbuffer.hpp + include/msgpack/object.hpp + include/msgpack/pack.hpp + include/msgpack/sbuffer.hpp + include/msgpack/type.hpp + include/msgpack/unpack.hpp + include/msgpack/version.hpp + include/msgpack/vrefbuffer.hpp + include/msgpack/zbuffer.hpp ) ENDIF () diff --git a/src/Makefile.am b/src/Makefile.am index 1d09559c..90391456 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -52,37 +52,40 @@ nobase_include_HEADERS = \ if ENABLE_CXX nobase_include_HEADERS += \ ../include/msgpack.hpp \ - ../include/msgpack/cpp_config.hpp \ - ../include/msgpack/sbuffer.hpp \ - ../include/msgpack/vrefbuffer.hpp \ - ../include/msgpack/zbuffer.hpp \ - ../include/msgpack/fbuffer.hpp \ - ../include/msgpack/pack.hpp \ - ../include/msgpack/unpack.hpp \ - ../include/msgpack/version.hpp \ - ../include/msgpack/object.hpp \ - ../include/msgpack/zone.hpp \ - ../include/msgpack/type.hpp \ - ../include/msgpack/detail/cpp11_zone.hpp \ ../include/msgpack/adaptor/bool.hpp \ + ../include/msgpack/adaptor/cpp11/tuple.hpp \ + ../include/msgpack/adaptor/define.hpp \ ../include/msgpack/adaptor/deque.hpp \ - ../include/msgpack/adaptor/float.hpp \ + ../include/msgpack/adaptor/detail/cpp03_define.hpp \ + ../include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp \ + ../include/msgpack/adaptor/detail/cpp11_define.hpp \ + ../include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp \ ../include/msgpack/adaptor/fixint.hpp \ + ../include/msgpack/adaptor/float.hpp \ ../include/msgpack/adaptor/int.hpp \ ../include/msgpack/adaptor/list.hpp \ ../include/msgpack/adaptor/map.hpp \ + ../include/msgpack/adaptor/msgpack_tuple.hpp \ ../include/msgpack/adaptor/nil.hpp \ ../include/msgpack/adaptor/pair.hpp \ ../include/msgpack/adaptor/raw.hpp \ ../include/msgpack/adaptor/set.hpp \ ../include/msgpack/adaptor/string.hpp \ - ../include/msgpack/adaptor/vector.hpp \ - ../include/msgpack/adaptor/msgpack_tuple.hpp \ - ../include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp \ - ../include/msgpack/adaptor/define.hpp \ - ../include/msgpack/adaptor/detail/cpp11_define.hpp \ ../include/msgpack/adaptor/tr1/unordered_map.hpp \ - ../include/msgpack/adaptor/tr1/unordered_set.hpp + ../include/msgpack/adaptor/tr1/unordered_set.hpp \ + ../include/msgpack/adaptor/vector.hpp \ + ../include/msgpack/cpp_config.hpp \ + ../include/msgpack/detail/cpp03_zone.hpp \ + ../include/msgpack/detail/cpp11_zone.hpp \ + ../include/msgpack/fbuffer.hpp \ + ../include/msgpack/object.hpp \ + ../include/msgpack/pack.hpp \ + ../include/msgpack/sbuffer.hpp \ + ../include/msgpack/type.hpp \ + ../include/msgpack/unpack.hpp \ + ../include/msgpack/version.hpp \ + ../include/msgpack/vrefbuffer.hpp \ + ../include/msgpack/zbuffer.hpp endif EXTRA_DIST = \ From 421aeb50213f04227362efe0b634aff8ddd40d66 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 24 Jul 2014 23:49:35 +0900 Subject: [PATCH 090/153] Fixed missing copy operation for zone.hpp --- CMakeLists.txt | 1 + src/Makefile.am | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f83836b2..9c0caa51 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -112,6 +112,7 @@ IF (MSGPACK_ENABLE_CXX) include/msgpack/version.hpp include/msgpack/vrefbuffer.hpp include/msgpack/zbuffer.hpp + include/msgpack/zone.hpp ) ENDIF () diff --git a/src/Makefile.am b/src/Makefile.am index 90391456..a729e102 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -85,7 +85,8 @@ nobase_include_HEADERS += \ ../include/msgpack/unpack.hpp \ ../include/msgpack/version.hpp \ ../include/msgpack/vrefbuffer.hpp \ - ../include/msgpack/zbuffer.hpp + ../include/msgpack/zbuffer.hpp \ + ../include/msgpack/zone.hpp endif EXTRA_DIST = \ From 6fab3594a2aefa3df78f88e220fa0895a730cb68 Mon Sep 17 00:00:00 2001 From: Scott Prager Date: Thu, 24 Jul 2014 15:04:33 -0400 Subject: [PATCH 091/153] Add inline for ODR compliance. --- include/msgpack/object.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index fdd9a53b..8509b96c 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -468,7 +468,7 @@ packer& operator<< (packer& o, const object& v) } } -std::ostream& operator<< (std::ostream& s, const object& o) +inline std::ostream& operator<< (std::ostream& s, const object& o) { switch(o.type) { case type::NIL: From 78e8cbdfb5cc8e6724f9269f7417dc8a02886cc5 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 3 Aug 2014 07:09:03 +0900 Subject: [PATCH 092/153] Cleaned up pointer and reference versions of unpack(). --- include/msgpack/unpack.hpp | 73 +++++++++---- test/msgpack_test.cpp | 64 +++++------ test/object.cc | 5 +- test/pack_unpack.cc | 216 +++++++++++++++++++++++++++++++++++-- 4 files changed, 293 insertions(+), 65 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 4c741a21..7bcca0f3 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -873,11 +873,13 @@ private: unpacker& operator=(const unpacker&); }; - inline void unpack(unpacked& result, - const char* data, size_t len, size_t* offset = nullptr); + const char* data, size_t len, size_t& off); +inline void unpack(unpacked& result, + const char* data, size_t len); +// obsolete inline void unpack(unpacked* result, - const char* data, size_t len, size_t* offset = nullptr); + const char* data, size_t len, size_t* off = nullptr); // obsolete typedef enum { @@ -888,14 +890,17 @@ typedef enum { } unpack_return; // obsolete -static unpack_return unpack(const char* data, size_t len, size_t* off, +static unpack_return unpack(const char* data, size_t len, size_t& off, + zone& z, object& result); +static unpack_return unpack(const char* data, size_t len, zone& z, object& result); static unpack_return unpack(const char* data, size_t len, size_t* off, zone* z, object* result); // obsolete -static object unpack(const char* data, size_t len, zone& z, size_t* off = nullptr); +static object unpack(const char* data, size_t len, zone& z, size_t& off); +static object unpack(const char* data, size_t len, zone& z); static object unpack(const char* data, size_t len, zone* z, size_t* off = nullptr); @@ -1176,11 +1181,10 @@ inline void unpacker::remove_nonparsed_buffer() namespace detail { inline unpack_return -unpack_imp(const char* data, size_t len, size_t* off, +unpack_imp(const char* data, size_t len, size_t& off, zone& result_zone, object& result) { - size_t noff = 0; - if(off != nullptr) { noff = *off; } + size_t noff = off; if(len <= noff) { // FIXME @@ -1198,7 +1202,7 @@ unpack_imp(const char* data, size_t len, size_t* off, return UNPACK_PARSE_ERROR; } - if(off != nullptr) { *off = noff; } + off = noff; if(e == 0) { return UNPACK_CONTINUE; @@ -1217,13 +1221,13 @@ unpack_imp(const char* data, size_t len, size_t* off, // reference version inline void unpack(unpacked& result, - const char* data, size_t len, size_t* offset) + const char* data, size_t len, size_t& off) { object obj; msgpack::unique_ptr z(new zone()); unpack_return ret = detail::unpack_imp( - data, len, offset, *z, obj); + data, len, off, *z, obj); switch(ret) { @@ -1245,31 +1249,51 @@ inline void unpack(unpacked& result, throw unpack_error("parse error"); } } + +inline void unpack(unpacked& result, + const char* data, size_t len) +{ + std::size_t off = 0; + return unpack(result, data, len, off); +} + +// obsolete // pointer version inline void unpack(unpacked* result, - const char* data, size_t len, size_t* offset) { - unpack(*result, data, len, offset); + const char* data, size_t len, size_t* off) { + if (off) unpack(*result, data, len, *off); + else unpack(*result, data, len); } // obsolete // reference version -inline unpack_return unpack(const char* data, size_t len, size_t* off, +inline unpack_return unpack(const char* data, size_t len, size_t& off, zone& z, object& result) { - return detail::unpack_imp(data, len, off, - z, result); + return detail::unpack_imp(data, len, off, z, result); } + +// obsolete +inline unpack_return unpack(const char* data, size_t len, + zone& z, object& result) +{ + std::size_t off = 0; + return detail::unpack_imp(data, len, off, z, result); +} + +// obsolete // pointer version inline unpack_return unpack(const char* data, size_t len, size_t* off, zone* z, object* result) { - return unpack(data, len, off, *z, *result); + if (off) return unpack(data, len, *off, *z, *result); + else return unpack(data, len, *z, *result); } // obsolete // reference version -inline object unpack(const char* data, size_t len, zone& z, size_t* off) +inline object unpack(const char* data, size_t len, zone& z, size_t& off) { object result; @@ -1292,10 +1316,21 @@ inline object unpack(const char* data, size_t len, zone& z, size_t* off) throw unpack_error("parse error"); } } + +// obsolete +inline object unpack(const char* data, size_t len, zone& z) +{ + std::size_t off = 0; + return unpack(data, len, z, off); +} + + +// obsolete // pointer version inline object unpack(const char* data, size_t len, zone* z, size_t* off) { - return unpack(data, len, *z, off); + if (off) return unpack(data, len, *z, *off); + else return unpack(data, len, *z); } } // namespace msgpack diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index c3479e63..08027497 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,7 +38,7 @@ const double kEPS = 1e-10; msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ @@ -165,7 +165,7 @@ TEST(MSGPACK, simple_buffer_float) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float val2; obj.convert(&val2); @@ -213,7 +213,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); float_type val2; obj.convert(&val2); @@ -255,7 +255,7 @@ TEST(MSGPACK, simple_buffer_double) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); double val2; obj.convert(&val2); @@ -277,7 +277,7 @@ TEST(MSGPACK, simple_buffer_true) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -292,7 +292,7 @@ TEST(MSGPACK, simple_buffer_false) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); bool val2; obj.convert(&val2); @@ -314,7 +314,7 @@ TEST(MSGPACK_STL, simple_buffer_string) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); string val2; obj.convert(&val2); @@ -334,7 +334,7 @@ TEST(MSGPACK_STL, simple_buffer_vector) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); vector val2; obj.convert(&val2); @@ -354,7 +354,7 @@ TEST(MSGPACK_STL, simple_buffer_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); map val2; obj.convert(&val2); @@ -374,7 +374,7 @@ TEST(MSGPACK_STL, simple_buffer_deque) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); deque val2; obj.convert(&val2); @@ -394,7 +394,7 @@ TEST(MSGPACK_STL, simple_buffer_list) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); list val2; obj.convert(&val2); @@ -414,7 +414,7 @@ TEST(MSGPACK_STL, simple_buffer_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); set val2; obj.convert(&val2); @@ -432,7 +432,7 @@ TEST(MSGPACK_STL, simple_buffer_pair) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); pair val2; obj.convert(&val2); @@ -455,7 +455,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multimap val2; obj.convert(&val2); @@ -485,7 +485,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); multiset val2; obj.convert(&val2); @@ -520,7 +520,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_map val2; obj.convert(&val2); @@ -547,7 +547,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multimap val2; obj.convert(&val2); @@ -581,7 +581,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_set val2; obj.convert(&val2); @@ -603,7 +603,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); tr1::unordered_multiset val2; obj.convert(&val2); @@ -637,7 +637,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_map val2; obj.convert(&val2); @@ -664,7 +664,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_multimap val2; obj.convert(&val2); @@ -698,7 +698,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_set val2; obj.convert(&val2); @@ -720,7 +720,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); unordered_multiset val2; obj.convert(&val2); @@ -751,7 +751,7 @@ TEST(MSGPACK_CPP11, simple_tuple) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); std::tuple val2; obj.convert(&val2); @@ -780,7 +780,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -813,7 +813,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass2 val2; val2.i = -1; @@ -835,7 +835,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestClass val2; val2.i = -1; @@ -876,7 +876,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestEnumMemberClass val2; val2.t1 = TestEnumMemberClass::STATE_INVALID; @@ -919,7 +919,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestEnumClassMemberClass val2; val2.t1 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID; @@ -984,7 +984,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -999,7 +999,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); TestUnionMemberClass val2; obj.convert(&val2); @@ -1027,7 +1027,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::zone z; \ msgpack::object obj; \ msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); \ + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); \ EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ test_type val2; \ obj.convert(&val2); \ diff --git a/test/object.cc b/test/object.cc index 627ca1a1..8742179f 100644 --- a/test/object.cc +++ b/test/object.cc @@ -37,7 +37,7 @@ TEST(object, convert) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); myclass m2; @@ -58,7 +58,7 @@ TEST(object, as) msgpack::object obj; msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(m1, obj.as()); @@ -131,4 +131,3 @@ TEST(object, construct_primitive) EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type); EXPECT_EQ(true, obj_bool.via.boolean); } - diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index 3805a4a6..7f2afd45 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -50,7 +50,7 @@ TEST(pack, myclass) } -TEST(unpack, myclass) +TEST(unpack, myclass_no_offset) { msgpack::sbuffer sbuf; myclass m1(1, "phraser"); @@ -59,8 +59,9 @@ TEST(unpack, myclass) msgpack::zone z; msgpack::object obj; + // obsolete msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj); + msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); @@ -69,6 +70,125 @@ TEST(unpack, myclass) EXPECT_EQ(m1.str, m2.str); } +TEST(unpack, myclass_offset) +{ + msgpack::sbuffer sbuf; + myclass m1(1, "phraser"); + msgpack::pack(sbuf, m1); + + msgpack::zone z; + msgpack::object obj; + std::size_t off = 0; + // obsolete + msgpack::unpack_return ret = + msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); + + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + + myclass m2 = obj.as(); + EXPECT_EQ(m1.num, m2.num); + EXPECT_EQ(m1.str, m2.str); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, myclass_offset_pointer) +{ + msgpack::sbuffer sbuf; + myclass m1(1, "phraser"); + msgpack::pack(sbuf, m1); + + msgpack::zone z; + msgpack::object obj; + std::size_t off = 0; + // obsolete + msgpack::unpack_return ret = + msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj); + + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + + myclass m2 = obj.as(); + EXPECT_EQ(m1.num, m2.num); + EXPECT_EQ(m1.str, m2.str); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, myclass_offset_null_pointer) +{ + msgpack::sbuffer sbuf; + myclass m1(1, "phraser"); + msgpack::pack(sbuf, m1); + + msgpack::zone z; + msgpack::object obj; + // obsolete + msgpack::unpack_return ret = + msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj); + + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + + myclass m2 = obj.as(); + EXPECT_EQ(m1.num, m2.num); + EXPECT_EQ(m1.str, m2.str); +} + +TEST(unpack, int_no_offset) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + msgpack::unpack(msg, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, int_offset) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + std::size_t off = 0; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + std::size_t off = 0; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_null_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, int_default_null_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} TEST(unpack, sequence) { @@ -77,18 +197,90 @@ TEST(unpack, sequence) msgpack::pack(sbuf, 2); msgpack::pack(sbuf, 3); - size_t offset = 0; + std::size_t off = 0; msgpack::unpacked msg; - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); EXPECT_EQ(1, msg.get().as()); - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); EXPECT_EQ(2, msg.get().as()); - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset); + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); EXPECT_EQ(3, msg.get().as()); + + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack_return, int_no_offset) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::zone z; + msgpack::object obj; + msgpack::unpack_return ret; + + // obsolete + ret = msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); + EXPECT_TRUE(ret >= 0); + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + EXPECT_EQ(1, obj.as()); +} + +TEST(unpack_return, int_offset) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + std::size_t off = 0; + + msgpack::zone z; + msgpack::object obj; + msgpack::unpack_return ret; + + // obsolete + ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); + EXPECT_TRUE(ret >= 0); + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack_return, int_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + std::size_t off = 0; + + msgpack::zone z; + msgpack::object obj; + msgpack::unpack_return ret; + + // obsolete + ret = msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj); + EXPECT_TRUE(ret >= 0); + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack_return, int_null_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::zone z; + msgpack::object obj; + msgpack::unpack_return ret; + + // obsolete + ret = msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj); + EXPECT_TRUE(ret >= 0); + EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + EXPECT_EQ(1, obj.as()); } @@ -99,25 +291,27 @@ TEST(unpack, sequence_compat) msgpack::pack(sbuf, 2); msgpack::pack(sbuf, 3); - size_t offset = 0; + std::size_t off = 0; msgpack::zone z; msgpack::object obj; msgpack::unpack_return ret; - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + // obsolete + ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(1, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + // obsolete + ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); EXPECT_EQ(2, obj.as()); - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj); + // obsolete + ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); EXPECT_TRUE(ret >= 0); EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); EXPECT_EQ(3, obj.as()); } - From 55bf279a7caccdc0fe2f1af569cbcb9c4d4fac78 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 3 Aug 2014 08:08:08 +0900 Subject: [PATCH 093/153] Removed obsolete unpack interface from test codes. --- test/msgpack_test.cpp | 321 ++++++++++++------------------------------ test/object.cc | 20 +-- 2 files changed, 99 insertions(+), 242 deletions(-) diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 08027497..affe6f7f 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -35,14 +35,9 @@ const double kEPS = 1e-10; msgpack::sbuffer sbuf; \ test_type val1 = v[i]; \ msgpack::pack(sbuf, val1); \ - msgpack::zone z; \ - msgpack::object obj; \ - msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); \ - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ - test_type val2; \ - obj.convert(&val2); \ - EXPECT_EQ(val1, val2); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + EXPECT_EQ(val1, ret.get().as()); \ } \ } while(0) @@ -162,13 +157,9 @@ TEST(MSGPACK, simple_buffer_float) msgpack::sbuffer sbuf; float val1 = v[i]; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - float val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float val2 = ret.get().as(); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -210,13 +201,9 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) msgpack::sbuffer sbuf; integer_type val1 = v[i]; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - float_type val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float_type val2 = ret.get().as(); EXPECT_TRUE(fabs(val2 - val1) <= kEPS); } } @@ -252,13 +239,9 @@ TEST(MSGPACK, simple_buffer_double) msgpack::sbuffer sbuf; double val1 = v[i]; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - double val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + double val2 = ret.get().as(); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -274,13 +257,9 @@ TEST(MSGPACK, simple_buffer_true) msgpack::sbuffer sbuf; bool val1 = true; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - bool val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); } @@ -289,13 +268,9 @@ TEST(MSGPACK, simple_buffer_false) msgpack::sbuffer sbuf; bool val1 = false; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - bool val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); } @@ -311,13 +286,9 @@ TEST(MSGPACK_STL, simple_buffer_string) val1 += 'a' + rand() % 26; msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - string val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + string val2 = ret.get().as(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1, val2); } @@ -331,13 +302,9 @@ TEST(MSGPACK_STL, simple_buffer_vector) val1.push_back(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - vector val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + vector val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -351,13 +318,9 @@ TEST(MSGPACK_STL, simple_buffer_map) val1[rand()] = rand(); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - map val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + map val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -371,13 +334,9 @@ TEST(MSGPACK_STL, simple_buffer_deque) val1.push_back(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - deque val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + deque val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -391,13 +350,9 @@ TEST(MSGPACK_STL, simple_buffer_list) val1.push_back(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - list val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + list val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -411,13 +366,9 @@ TEST(MSGPACK_STL, simple_buffer_set) val1.insert(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - set val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + set val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } @@ -429,13 +380,9 @@ TEST(MSGPACK_STL, simple_buffer_pair) pair val1 = make_pair(rand(), rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - pair val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + pair val2 = ret.get().as >(); EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.second, val2.second); } @@ -452,13 +399,9 @@ TEST(MSGPACK_STL, simple_buffer_multimap) } msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - multimap val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multimap val2 = ret.get().as >(); vector > v1, v2; multimap::const_iterator it; @@ -482,13 +425,9 @@ TEST(MSGPACK_STL, simple_buffer_multiset) val1.insert(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - multiset val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multiset val2 = ret.get().as >(); vector v1, v2; multiset::const_iterator it; @@ -517,13 +456,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) val1[rand()] = rand(); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_map val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_map val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); tr1::unordered_map::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) { @@ -544,13 +479,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) } msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_multimap val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multimap val2 = ret.get().as >(); vector > v1, v2; tr1::unordered_multimap::const_iterator it; @@ -578,13 +509,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) val1.insert(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_set val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_set val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); tr1::unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) @@ -600,13 +527,9 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) val1.insert(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - tr1::unordered_multiset val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multiset val2 = ret.get().as >(); vector v1, v2; tr1::unordered_multiset::const_iterator it; @@ -634,13 +557,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map) val1[rand()] = rand(); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_map val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_map val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); unordered_map::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) { @@ -661,13 +580,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) } msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_multimap val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multimap val2 = ret.get().as >(); vector > v1, v2; unordered_multimap::const_iterator it; @@ -695,13 +610,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set) val1.insert(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_set val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_set val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) @@ -717,13 +628,9 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) val1.insert(rand()); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - unordered_multiset val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multiset val2 = ret.get().as >(); vector v1, v2; unordered_multiset::const_iterator it; @@ -748,13 +655,9 @@ TEST(MSGPACK_CPP11, simple_tuple) msgpack::sbuffer sbuf; std::tuple val1(true, "kzk", 12.3); msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - std::tuple val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + std::tuple val2 = ret.get().as >(); EXPECT_EQ(val1, val2); } @@ -777,15 +680,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) TestClass val1; msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestClass val2; - val2.i = -1; - val2.s = ""; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass val2 = ret.get().as(); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); } @@ -832,15 +729,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) TestClass2 val1; msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestClass val2; - val2.i = -1; - val2.s = ""; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass val2 = ret.get().as(); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); @@ -873,16 +764,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) TestEnumMemberClass val1; msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestEnumMemberClass val2; - val2.t1 = TestEnumMemberClass::STATE_INVALID; - val2.t2 = TestEnumMemberClass::STATE_INVALID; - val2.t3 = TestEnumMemberClass::STATE_INVALID; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestEnumMemberClass val2 = ret.get().as(); EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); @@ -916,16 +800,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) TestEnumClassMemberClass val1; msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestEnumClassMemberClass val2; - val2.t1 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID; - val2.t2 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID; - val2.t3 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestEnumClassMemberClass val2 = ret.get().as(); EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); @@ -981,13 +858,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) TestUnionMemberClass val1(1.0); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestUnionMemberClass val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestUnionMemberClass val2 = ret.get().as(); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); } @@ -996,13 +869,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) TestUnionMemberClass val1(1); msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestUnionMemberClass val2; - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestUnionMemberClass val2 = ret.get().as(); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.value.i, 1); EXPECT_EQ(val1.value.i, val2.value.i); @@ -1024,13 +893,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) const struct iovec* end = cur + vbuf.vector_size(); \ for(; cur != end; ++cur) \ sbuf.write((const char*)cur->iov_base, cur->iov_len); \ - msgpack::zone z; \ - msgpack::object obj; \ - msgpack::unpack_return ret = \ - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); \ - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); \ - test_type val2; \ - obj.convert(&val2); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + test_type val2 = ret.get().as(); \ EXPECT_EQ(val1, val2); \ } \ } while(0); diff --git a/test/object.cc b/test/object.cc index 8742179f..88490fb5 100644 --- a/test/object.cc +++ b/test/object.cc @@ -33,15 +33,11 @@ TEST(object, convert) msgpack::sbuffer sbuf; msgpack::pack(sbuf, m1); - msgpack::zone z; - msgpack::object obj; - - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); myclass m2; - obj.convert(&m2); + ret.get().convert(&m2); EXPECT_EQ(m1, m2); } @@ -54,14 +50,10 @@ TEST(object, as) msgpack::sbuffer sbuf; msgpack::pack(sbuf, m1); - msgpack::zone z; - msgpack::object obj; + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - - EXPECT_EQ(m1, obj.as()); + EXPECT_EQ(m1, ret.get().as()); } From 3729f334a1505e7d25e84540fedbd8ee496ee446 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 3 Aug 2014 16:34:47 +0900 Subject: [PATCH 094/153] Replaced size_t with std::size_t. --- include/msgpack/unpack.hpp | 112 ++++++++++++++++++------------------- 1 file changed, 56 insertions(+), 56 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 7bcca0f3..68b9216f 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -168,16 +168,16 @@ public: object const& obj() const { return m_obj; } object& obj() { return m_obj; } void set_obj(object const& obj) { m_obj = obj; } - size_t count() const { return m_count; } - void set_count(size_t count) { m_count = count; } - size_t decl_count() { return --m_count; } + std::size_t count() const { return m_count; } + void set_count(std::size_t count) { m_count = count; } + std::size_t decl_count() { return --m_count; } unsigned int container_type() const { return m_container_type; } void set_container_type(unsigned int container_type) { m_container_type = container_type; } object const& map_key() const { return m_map_key; } void set_map_key(object const& map_key) { m_map_key = map_key; } private: object m_obj; - size_t m_count; + std::size_t m_count; unsigned int m_container_type; object m_map_key; }; @@ -272,7 +272,7 @@ public: return m_user; } - int execute(const char* data, size_t len, size_t& off) + int execute(const char* data, std::size_t len, std::size_t& off) { assert(len >= off); @@ -400,7 +400,7 @@ public: ++m_current; fixed_trail_again = false; } - if((size_t)(pe - m_current) < m_trail) { + if((std::size_t)(pe - m_current) < m_trail) { off = m_current - m_start; return 0; } @@ -619,7 +619,7 @@ private: unsigned int container_type, object& obj, const char* load_pos, - size_t& off) { + std::size_t& off) { if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { typename value::type tmp; load(tmp, load_pos); @@ -693,7 +693,7 @@ private: return 0; } - int push_proc(object& obj, size_t& off) { + int push_proc(object& obj, std::size_t& off) { int ret = push_item(obj); if (ret > 0) { m_stack[0].set_obj(obj); @@ -759,7 +759,7 @@ private: class unpacker { public: - unpacker(size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + unpacker(std::size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); #if !defined(MSGPACK_USE_CPP03) unpacker(unpacker&& other); @@ -770,20 +770,20 @@ public: public: /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ - void reserve_buffer(size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); + void reserve_buffer(std::size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); /*! 2. read data to the buffer() up to buffer_capacity() bytes */ char* buffer(); - size_t buffer_capacity() const; + std::size_t buffer_capacity() const; /*! 3. specify the number of bytes actually copied */ - void buffer_consumed(size_t size); + void buffer_consumed(std::size_t size); /*! 4. repeat next() until it retunrs false */ bool next(unpacked* result); /*! 5. check if the size of message doesn't exceed assumption. */ - size_t message_size() const; + std::size_t message_size() const; // Basic usage of the unpacker is as following: // @@ -794,7 +794,7 @@ public: // pac.reserve_buffer(32*1024); // // // 2. - // size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity()); + // std::size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity()); // // // error handling ... // @@ -839,33 +839,33 @@ public: public: // These functions are usable when non-MessagePack message follows after // MessagePack message. - size_t parsed_size() const; + std::size_t parsed_size() const; /*! get address of the buffer that is not parsed */ char* nonparsed_buffer(); - size_t nonparsed_size() const; + std::size_t nonparsed_size() const; /*! skip specified size of non-parsed buffer, leaving the buffer */ // Note that the `size' argument must be smaller than nonparsed_size() - void skip_nonparsed_buffer(size_t size); + void skip_nonparsed_buffer(std::size_t size); /*! remove unparsed buffer from unpacker */ // Note that reset() leaves non-parsed buffer. void remove_nonparsed_buffer(); private: - void expand_buffer(size_t size); + void expand_buffer(std::size_t size); int execute_imp(); bool flush_zone(); private: char* m_buffer; - size_t m_used; - size_t m_free; - size_t m_off; - size_t m_parsed; + std::size_t m_used; + std::size_t m_free; + std::size_t m_off; + std::size_t m_parsed; zone* m_z; - size_t m_initial_buffer_size; + std::size_t m_initial_buffer_size; detail::context m_ctx; private: @@ -874,12 +874,12 @@ private: }; inline void unpack(unpacked& result, - const char* data, size_t len, size_t& off); + const char* data, std::size_t len, std::size_t& off); inline void unpack(unpacked& result, - const char* data, size_t len); + const char* data, std::size_t len); // obsolete inline void unpack(unpacked* result, - const char* data, size_t len, size_t* off = nullptr); + const char* data, std::size_t len, std::size_t* off = nullptr); // obsolete typedef enum { @@ -890,21 +890,21 @@ typedef enum { } unpack_return; // obsolete -static unpack_return unpack(const char* data, size_t len, size_t& off, +static unpack_return unpack(const char* data, std::size_t len, std::size_t& off, zone& z, object& result); -static unpack_return unpack(const char* data, size_t len, +static unpack_return unpack(const char* data, std::size_t len, zone& z, object& result); -static unpack_return unpack(const char* data, size_t len, size_t* off, +static unpack_return unpack(const char* data, std::size_t len, std::size_t* off, zone* z, object* result); // obsolete -static object unpack(const char* data, size_t len, zone& z, size_t& off); -static object unpack(const char* data, size_t len, zone& z); -static object unpack(const char* data, size_t len, zone* z, size_t* off = nullptr); +static object unpack(const char* data, std::size_t len, zone& z, std::size_t& off); +static object unpack(const char* data, std::size_t len, zone& z); +static object unpack(const char* data, std::size_t len, zone* z, std::size_t* off = nullptr); -inline unpacker::unpacker(size_t initial_buffer_size) +inline unpacker::unpacker(std::size_t initial_buffer_size) { if(initial_buffer_size < COUNTER_SIZE) { initial_buffer_size = COUNTER_SIZE; @@ -969,13 +969,13 @@ inline unpacker::~unpacker() } -inline void unpacker::reserve_buffer(size_t size) +inline void unpacker::reserve_buffer(std::size_t size) { if(m_free >= size) return; expand_buffer(size); } -inline void unpacker::expand_buffer(size_t size) +inline void unpacker::expand_buffer(std::size_t size) { if(m_used == m_off && detail::get_count(m_buffer) == 1 && !m_ctx.user().referenced()) { @@ -988,7 +988,7 @@ inline void unpacker::expand_buffer(size_t size) } if(m_off == COUNTER_SIZE) { - size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE + std::size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE while(next_size < size + m_used) { next_size *= 2; } @@ -1002,8 +1002,8 @@ inline void unpacker::expand_buffer(size_t size) m_free = next_size - m_used; } else { - size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE - size_t not_parsed = m_used - m_off; + std::size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE + std::size_t not_parsed = m_used - m_off; while(next_size < size + not_parsed + COUNTER_SIZE) { next_size *= 2; } @@ -1042,12 +1042,12 @@ inline char* unpacker::buffer() return m_buffer + m_used; } -inline size_t unpacker::buffer_capacity() const +inline std::size_t unpacker::buffer_capacity() const { return m_free; } -inline void unpacker::buffer_consumed(size_t size) +inline void unpacker::buffer_consumed(std::size_t size) { m_used += size; m_free -= size; @@ -1089,7 +1089,7 @@ inline bool unpacker::execute() inline int unpacker::execute_imp() { - size_t off = m_off; + std::size_t off = m_off; int ret = m_ctx.execute(m_buffer, m_used, m_off); if(m_off > off) { m_parsed += m_off - off; @@ -1148,12 +1148,12 @@ inline void unpacker::reset() m_parsed = 0; } -inline size_t unpacker::message_size() const +inline std::size_t unpacker::message_size() const { return m_parsed - m_off + m_used; } -inline size_t unpacker::parsed_size() const +inline std::size_t unpacker::parsed_size() const { return m_parsed; } @@ -1163,12 +1163,12 @@ inline char* unpacker::nonparsed_buffer() return m_buffer + m_off; } -inline size_t unpacker::nonparsed_size() const +inline std::size_t unpacker::nonparsed_size() const { return m_used - m_off; } -inline void unpacker::skip_nonparsed_buffer(size_t size) +inline void unpacker::skip_nonparsed_buffer(std::size_t size) { m_off += size; } @@ -1181,10 +1181,10 @@ inline void unpacker::remove_nonparsed_buffer() namespace detail { inline unpack_return -unpack_imp(const char* data, size_t len, size_t& off, +unpack_imp(const char* data, std::size_t len, std::size_t& off, zone& result_zone, object& result) { - size_t noff = off; + std::size_t noff = off; if(len <= noff) { // FIXME @@ -1221,7 +1221,7 @@ unpack_imp(const char* data, size_t len, size_t& off, // reference version inline void unpack(unpacked& result, - const char* data, size_t len, size_t& off) + const char* data, std::size_t len, std::size_t& off) { object obj; msgpack::unique_ptr z(new zone()); @@ -1251,7 +1251,7 @@ inline void unpack(unpacked& result, } inline void unpack(unpacked& result, - const char* data, size_t len) + const char* data, std::size_t len) { std::size_t off = 0; return unpack(result, data, len, off); @@ -1260,7 +1260,7 @@ inline void unpack(unpacked& result, // obsolete // pointer version inline void unpack(unpacked* result, - const char* data, size_t len, size_t* off) { + const char* data, std::size_t len, std::size_t* off) { if (off) unpack(*result, data, len, *off); else unpack(*result, data, len); } @@ -1268,14 +1268,14 @@ inline void unpack(unpacked* result, // obsolete // reference version -inline unpack_return unpack(const char* data, size_t len, size_t& off, +inline unpack_return unpack(const char* data, std::size_t len, std::size_t& off, zone& z, object& result) { return detail::unpack_imp(data, len, off, z, result); } // obsolete -inline unpack_return unpack(const char* data, size_t len, +inline unpack_return unpack(const char* data, std::size_t len, zone& z, object& result) { std::size_t off = 0; @@ -1284,7 +1284,7 @@ inline unpack_return unpack(const char* data, size_t len, // obsolete // pointer version -inline unpack_return unpack(const char* data, size_t len, size_t* off, +inline unpack_return unpack(const char* data, std::size_t len, std::size_t* off, zone* z, object* result) { if (off) return unpack(data, len, *off, *z, *result); @@ -1293,7 +1293,7 @@ inline unpack_return unpack(const char* data, size_t len, size_t* off, // obsolete // reference version -inline object unpack(const char* data, size_t len, zone& z, size_t& off) +inline object unpack(const char* data, std::size_t len, zone& z, std::size_t& off) { object result; @@ -1318,7 +1318,7 @@ inline object unpack(const char* data, size_t len, zone& z, size_t& off) } // obsolete -inline object unpack(const char* data, size_t len, zone& z) +inline object unpack(const char* data, std::size_t len, zone& z) { std::size_t off = 0; return unpack(data, len, z, off); @@ -1327,7 +1327,7 @@ inline object unpack(const char* data, size_t len, zone& z) // obsolete // pointer version -inline object unpack(const char* data, size_t len, zone* z, size_t* off) +inline object unpack(const char* data, std::size_t len, zone* z, std::size_t* off) { if (off) return unpack(data, len, *z, *off); else return unpack(data, len, *z); From b27c87c9ed7502fd275d2ef76e52e05a83ced7dc Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 3 Aug 2014 16:38:58 +0900 Subject: [PATCH 095/153] Replaced C-Style cast with static_cast. --- include/msgpack/unpack.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 68b9216f..9e2fae02 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -400,7 +400,7 @@ public: ++m_current; fixed_trail_again = false; } - if((std::size_t)(pe - m_current) < m_trail) { + if(static_cast(pe - m_current) < m_trail) { off = m_current - m_start; return 0; } From e4d32b176e7b3b3c38713cc89eefe59f63cbfa76 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 3 Aug 2014 17:04:46 +0900 Subject: [PATCH 096/153] Use const char* version of msgpack::unpack_error to avoid std::string memory allocation when usr C++11 compiler. See http://www.cplusplus.com/reference/stdexcept/runtime_error/?kw=runtime_error --- include/msgpack/unpack.hpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 9e2fae02..da56cb58 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -727,8 +727,13 @@ private: struct unpack_error : public std::runtime_error { +#if defined(MSGPACK_USE_CPP03) unpack_error(const std::string& msg) : std::runtime_error(msg) { } +#else + unpack_error(const char* msg) : + std::runtime_error(msg) { } +#endif }; From fd566afeb46b7082407a4730f91f80561af38a91 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 4 Aug 2014 00:52:04 +0900 Subject: [PATCH 097/153] Added reference version of unpacker::next(). --- include/msgpack/unpack.hpp | 16 ++++++++----- test/streaming.cc | 46 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 5 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index da56cb58..9836d65d 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -786,6 +786,7 @@ public: /*! 4. repeat next() until it retunrs false */ bool next(unpacked* result); + bool next(unpacked& result); /*! 5. check if the size of message doesn't exceed assumption. */ std::size_t message_size() const; @@ -1058,7 +1059,7 @@ inline void unpacker::buffer_consumed(std::size_t size) m_free -= size; } -inline bool unpacker::next(unpacked* result) +inline bool unpacker::next(unpacked& result) { int ret = execute_imp(); @@ -1067,18 +1068,23 @@ inline bool unpacker::next(unpacked* result) } if(ret == 0) { - result->zone().reset(); - result->set(object()); + result.zone().reset(); + result.set(object()); return false; } else { - result->zone().reset( release_zone() ); - result->set(data()); + result.zone().reset( release_zone() ); + result.set(data()); reset(); return true; } } +inline bool unpacker::next(unpacked* result) +{ + return next(*result); +} + inline bool unpacker::execute() { diff --git a/test/streaming.cc b/test/streaming.cc index c390dc18..4ecd2f60 100644 --- a/test/streaming.cc +++ b/test/streaming.cc @@ -17,6 +17,52 @@ TEST(streaming, basic) msgpack::unpacker pac; msgpack::unpacked result; + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); + + // read buffer into pac.buffer() upto + // pac.buffer_capacity() bytes. + size_t len = 1; + memcpy(pac.buffer(), input, len); + input += len; + + pac.buffer_consumed(len); + + while(pac.next(result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + } +} + +TEST(streaming, basic_pointer) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + int count = 0; while(count < 3) { pac.reserve_buffer(32*1024); From 66014eebc083b352ec4fad6995e0f102b334d536 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 4 Aug 2014 01:08:05 +0900 Subject: [PATCH 098/153] Updated test codes using recommended interface. They used to use obsolete interfaces. --- test/msgpack_test.cpp | 9 +++------ test/streaming.cc | 4 ++-- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index affe6f7f..e678385f 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -1017,17 +1017,14 @@ TEST(MSGPACK, vrefbuffer_int64) pac.reserve_buffer(sz); \ memcpy(pac.buffer(), p, sz); \ pac.buffer_consumed(sz); \ - while (pac.execute()) { \ + msgpack::unpacked result; \ + while (pac.next(result)) { \ if (it == vec.end()) goto out; \ - msgpack::object obj = pac.data(); \ - msgpack::zone *life = pac.release_zone(); \ - EXPECT_TRUE(life != NULL); \ - pac.reset(); \ + msgpack::object obj = result.get(); \ vec_type::value_type val; \ obj.convert(&val); \ EXPECT_EQ(*it, val); \ ++it; \ - msgpack::zone::destroy(life); \ } \ p += sz; \ } \ diff --git a/test/streaming.cc b/test/streaming.cc index 4ecd2f60..2daa98a1 100644 --- a/test/streaming.cc +++ b/test/streaming.cc @@ -124,7 +124,7 @@ TEST(streaming, move) pac_in.buffer_consumed(len); - while(pac_in.next(&result)) { + while(pac_in.next(result)) { msgpack::object obj = result.get(); switch(count++) { case 0: @@ -165,7 +165,7 @@ public: pac.buffer_consumed(len); msgpack::unpacked result; - while(pac.next(&result)) { + while(pac.next(result)) { on_message(result.get(), msgpack::move(result.zone())); } From 15a0d61a646c411c30497401ef97a6e94a763e13 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 4 Aug 2014 15:14:39 +0900 Subject: [PATCH 099/153] Added the new mapping: std::vector is mapped to BIN. So, currently BIN, STR, and ARRAY mappings are as follows: std::vector is mapped to BIN std::string is mapped to STR std::vector is mapped to ARRAY // T is not char --- include/msgpack/adaptor/vector_char.hpp | 72 +++++++++++++++++++++++++ include/msgpack/type.hpp | 1 + test/msgpack_test.cpp | 19 +++++++ 3 files changed, 92 insertions(+) create mode 100644 include/msgpack/adaptor/vector_char.hpp diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp new file mode 100644 index 00000000..642e97c6 --- /dev/null +++ b/include/msgpack/adaptor/vector_char.hpp @@ -0,0 +1,72 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_CHAR_HPP +#define MSGPACK_TYPE_VECTOR_CHAR_HPP + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + +inline std::vector& operator>> (object const& o, std::vector& v) +{ + switch (o.type) { + case type::BIN: + v.resize(o.via.bin.size); + std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size); + break; + case type::STR: + v.resize(o.via.str.size); + std::memcpy(v.data(), o.via.str.ptr, o.via.str.size); + break; + default: + throw type_error(); + break; + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::vector& v) +{ + o.pack_bin(v.size()); + o.pack_bin_body(v.data(), v.size()); + + return o; +} + +inline void operator<< (object& o, const std::vector& v) +{ + o.type = type::BIN; + o.via.bin.ptr = v.data(); + o.via.bin.size = static_cast(v.size()); +} + +inline void operator<< (object::with_zone& o, const std::vector& v) +{ + o.type = type::BIN; + char* ptr = static_cast(o.zone->allocate_align(v.size())); + o.via.bin.ptr = ptr; + o.via.bin.size = static_cast(v.size()); + std::memcpy(ptr, v.data(), v.size()); +} + +} // namespace msgpack + +#endif // MSGPACK_TYPE_VECTOR_CHAR_HPP + diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp index b3da55d4..29ab7348 100644 --- a/include/msgpack/type.hpp +++ b/include/msgpack/type.hpp @@ -12,6 +12,7 @@ #include "adaptor/set.hpp" #include "adaptor/string.hpp" #include "adaptor/vector.hpp" +#include "adaptor/vector_char.hpp" #include "adaptor/msgpack_tuple.hpp" #include "adaptor/define.hpp" #include "adaptor/tr1/unordered_map.hpp" diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index e678385f..0eeee25a 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -288,6 +288,7 @@ TEST(MSGPACK_STL, simple_buffer_string) msgpack::pack(sbuf, val1); msgpack::unpacked ret; msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); string val2 = ret.get().as(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1, val2); @@ -304,12 +305,30 @@ TEST(MSGPACK_STL, simple_buffer_vector) msgpack::pack(sbuf, val1); msgpack::unpacked ret; msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); vector val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); } } +TEST(MSGPACK_STL, simple_buffer_vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::BIN); + vector val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + TEST(MSGPACK_STL, simple_buffer_map) { for (unsigned int k = 0; k < kLoop; k++) { From 5af6d363413698468aea52b90401f7f9148415d9 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 4 Aug 2014 16:38:40 +0900 Subject: [PATCH 100/153] Added a link to wiki. --- README.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/README.md b/README.md index e3a34f3d..f9ce7de9 100644 --- a/README.md +++ b/README.md @@ -141,3 +141,10 @@ Install from package for this branch (poc/0.6) is not supported yet. // If the type is mismatched, it throws msgpack::type_error. obj.as(); // type is mismatched, msgpack::type_error is thrown } + +### Documents + +You can get addtional information on the wiki: + +https://github.com/msgpack/msgpack-c/wiki/cpp_overview + From ce21ab0ebf7e8847296ef312f1461fadd821faee Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 6 Aug 2014 12:16:28 +0900 Subject: [PATCH 101/153] Fixed zone allocating functions always throw std::bad_alloc() if allocation is failed. --- erb/cpp03_zone.hpp.erb | 3 ++- include/msgpack/detail/cpp03_zone.hpp | 3 ++- include/msgpack/detail/cpp11_zone.hpp | 4 ++-- include/msgpack/unpack.hpp | 33 ++++++++++----------------- 4 files changed, 18 insertions(+), 25 deletions(-) diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index 9fe142e8..212c315f 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -202,7 +202,7 @@ inline zone* zone::create(size_t chunk_size) { zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); if (!z) { - return nullptr; + throw std::bad_alloc(); } new (z) zone(chunk_size); return z; @@ -248,6 +248,7 @@ inline void* zone::allocate_expand(size_t size) } chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if (!c) throw std::bad_alloc(); char* ptr = reinterpret_cast(c) + sizeof(chunk); diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index 9e6471b9..143402f3 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -247,7 +247,7 @@ inline zone* zone::create(size_t chunk_size) { zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); if (!z) { - return nullptr; + throw std::bad_alloc(); } new (z) zone(chunk_size); return z; @@ -293,6 +293,7 @@ inline void* zone::allocate_expand(size_t size) } chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); + if (!c) throw std::bad_alloc(); char* ptr = reinterpret_cast(c) + sizeof(chunk); diff --git a/include/msgpack/detail/cpp11_zone.hpp b/include/msgpack/detail/cpp11_zone.hpp index 73d7d79f..7ea92863 100644 --- a/include/msgpack/detail/cpp11_zone.hpp +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -202,7 +202,7 @@ inline zone* zone::create(size_t chunk_size) { zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); if (!z) { - return nullptr; + throw std::bad_alloc(); } new (z) zone(chunk_size); return z; @@ -248,7 +248,7 @@ inline void* zone::allocate_expand(size_t size) } chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - if (!c) return nullptr; + if (!c) throw std::bad_alloc(); char* ptr = reinterpret_cast(c) + sizeof(chunk); diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 9836d65d..e3c7a535 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -106,12 +106,10 @@ inline void unpack_false(object& o) { o.type = type::BOOLEAN; o.via.boolean = false; } struct unpack_array { - bool operator()(unpack_user&u, unsigned int n, object& o) const { + void operator()(unpack_user&u, unsigned int n, object& o) const { o.type = type::ARRAY; o.via.array.size = 0; o.via.array.ptr = static_cast(u.zone().allocate_align(n*sizeof(object))); - if(o.via.array.ptr == nullptr) { return false; } - return true; } }; @@ -125,12 +123,10 @@ inline void unpack_array_item(object& c, object const& o) } struct unpack_map { - bool operator()(unpack_user& u, unsigned int n, object& o) const { + void operator()(unpack_user& u, unsigned int n, object& o) const { o.type = type::MAP; o.via.map.size = 0; o.via.map.ptr = static_cast(u.zone().allocate_align(n*sizeof(object_kv))); - if(o.via.map.ptr == nullptr) { return false; } - return true; } }; @@ -623,23 +619,18 @@ private: if(m_top < MSGPACK_EMBED_STACK_SIZE /* FIXME */) { typename value::type tmp; load(tmp, load_pos); - if (f(m_user, tmp, m_stack[m_top].obj())) { - if(tmp == 0) { - obj = m_stack[m_top].obj(); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_stack[m_top].set_container_type(container_type); - m_stack[m_top].set_count(tmp); - ++m_top; - m_cs = CS_HEADER; - ++m_current; - } + f(m_user, tmp, m_stack[m_top].obj()); + if(tmp == 0) { + obj = m_stack[m_top].obj(); + int ret = push_proc(obj, off); + if (ret != 0) return ret; } else { - off = m_current - m_start; - return -1; + m_stack[m_top].set_container_type(container_type); + m_stack[m_top].set_count(tmp); + ++m_top; + m_cs = CS_HEADER; + ++m_current; } } else { From 1f5d6b9cacaeab1edef6f372fa6e064cd2db2f4b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 6 Aug 2014 16:18:37 +0900 Subject: [PATCH 102/153] Added EXT support. Removed obsolete unpack functions. Updated examples that no longer use obsolete functions. Added reference checking function to unpacked. ( unpacked::referenced() ) Added std:: namespace. Added reference or copy choice function and default behavior: When you use unpacker, default behavior is: STR, BIN, EXT types are always held by reference. When you don't use unpacker, default behavior is: STR, BIN, EXT types are always held by copy. The memory is allocated from zone. You can customize the behavior passing your custom judging function to unpack() or unpacker's constructor. --- example/custom.cc | 12 +- example/protocol.cc | 17 +- example/simple.cc | 9 +- example/speed_test.cc | 18 +- example/speed_test_nested_array.cc | 18 +- include/msgpack/object.h | 3 +- include/msgpack/object.hpp | 20 +- include/msgpack/pack.hpp | 69 ++++++ include/msgpack/unpack.hpp | 372 ++++++++++++++++++----------- include/msgpack/unpack_define.h | 19 +- test/msgpack_test.cpp | 177 +++++++++++++- test/pack_unpack.cc | 185 -------------- 12 files changed, 519 insertions(+), 400 deletions(-) diff --git a/example/custom.cc b/example/custom.cc index f892a894..63cc4f4b 100644 --- a/example/custom.cc +++ b/example/custom.cc @@ -30,9 +30,9 @@ int main(void) msgpack::sbuffer sbuf; msgpack::pack(sbuf, oc); - msgpack::zone zone; - msgpack::object obj; - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); + msgpack::unpacked result; + msgpack::unpack(result, sbuf.data(), sbuf.size()); + msgpack::object obj = result.get(); obj.convert(&nc); @@ -46,9 +46,9 @@ int main(void) msgpack::sbuffer sbuf; msgpack::pack(sbuf, nc); - msgpack::zone zone; - msgpack::object obj; - msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &zone, &obj); + msgpack::unpacked result; + msgpack::unpack(result, sbuf.data(), sbuf.size()); + msgpack::object obj = result.get(); obj.convert(&oc); diff --git a/example/protocol.cc b/example/protocol.cc index efc431f7..5e08b291 100644 --- a/example/protocol.cc +++ b/example/protocol.cc @@ -46,12 +46,12 @@ int main(void) { std::string buffer(stream.str()); - msgpack::zone mempool; - msgpack::object o = - msgpack::unpack(buffer.data(), buffer.size(), mempool); + msgpack::unpacked result; + msgpack::unpack(result, buffer.data(), buffer.size()); + msgpack::object o = result.get(); myprotocol::Get req; - msgpack::convert(req, o); + o.convert(req); std::cout << "received: " << o << std::endl; } @@ -74,12 +74,13 @@ int main(void) { std::string buffer(stream.str()); - msgpack::zone mempool; - msgpack::object o = - msgpack::unpack(buffer.data(), buffer.size(), mempool); + msgpack::unpacked result; + msgpack::unpack(result, buffer.data(), buffer.size()); + msgpack::object o = result.get(); + myprotocol::MultiGet req; - msgpack::convert(req, o); + o.convert(req); std::cout << "received: " << o << std::endl; } } diff --git a/example/simple.cc b/example/simple.cc index 5bfd8278..0dcb9d84 100644 --- a/example/simple.cc +++ b/example/simple.cc @@ -18,11 +18,12 @@ int main(void) // deserialize the buffer into msgpack::object instance. std::string str(buffer.str()); - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; + msgpack::unpacked result; - msgpack::object deserialized; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); + msgpack::unpack(result, str.data(), str.size()); + + // deserialized object is valid during the msgpack::unpacked instance alive. + msgpack::object deserialized = result.get(); // msgpack::object supports ostream. std::cout << deserialized << std::endl; diff --git a/example/speed_test.cc b/example/speed_test.cc index b711c15e..d13eb777 100644 --- a/example/speed_test.cc +++ b/example/speed_test.cc @@ -28,23 +28,11 @@ void test_map_pack_unpack() { buffer.seekg(0); std::string str(buffer.str()); - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; - msgpack::object deserialized; - std::cout << "Start unpacking..." << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; - msgpack::unpacked unpacked; - std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; + std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl; { boost::timer::cpu_timer timer; - msgpack::unpack(&unpacked, str.data(), str.size()); + msgpack::unpack(unpacked, str.data(), str.size()); std::string result = timer.format(); std::cout << result << std::endl; } @@ -53,7 +41,7 @@ void test_map_pack_unpack() { std::cout << "Start converting..." << std::endl; { boost::timer::cpu_timer timer; - deserialized.convert(&m2); + unpacked.get().convert(&m2); std::string result = timer.format(); std::cout << result << std::endl; } diff --git a/example/speed_test_nested_array.cc b/example/speed_test_nested_array.cc index 8260f257..40a87a99 100644 --- a/example/speed_test_nested_array.cc +++ b/example/speed_test_nested_array.cc @@ -51,23 +51,11 @@ void test_array_of_array() { buffer.seekg(0); std::string str(buffer.str()); - // deserialized object is valid during the msgpack::zone instance alive. - msgpack::zone mempool; - msgpack::object deserialized; - std::cout << "Start unpacking..." << std::endl; - { - boost::timer::cpu_timer timer; - msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized); - std::string result = timer.format(); - std::cout << result << std::endl; - } - std::cout << "Unpack finished..." << std::endl; - msgpack::unpacked unpacked; - std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl; + std::cout << "Start unpacking...by void unpack(unpacked& result, const char* data, size_t len)" << std::endl; { boost::timer::cpu_timer timer; - msgpack::unpack(&unpacked, str.data(), str.size()); + msgpack::unpack(unpacked, str.data(), str.size()); std::string result = timer.format(); std::cout << result << std::endl; } @@ -76,7 +64,7 @@ void test_array_of_array() { std::cout << "Start converting..." << std::endl; { boost::timer::cpu_timer timer; - deserialized.convert(&v2); + unpacked.get().convert(&v2); std::string result = timer.format(); std::cout << result << std::endl; } diff --git a/include/msgpack/object.h b/include/msgpack/object.h index 79859db2..560008fe 100644 --- a/include/msgpack/object.h +++ b/include/msgpack/object.h @@ -41,7 +41,8 @@ typedef enum { MSGPACK_OBJECT_STR = 0x05, MSGPACK_OBJECT_ARRAY = 0x06, MSGPACK_OBJECT_MAP = 0x07, - MSGPACK_OBJECT_BIN = 0x08 + MSGPACK_OBJECT_BIN = 0x08, + MSGPACK_OBJECT_EXT = 0x09 } msgpack_object_type; diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index 8509b96c..f0790279 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -43,7 +43,8 @@ namespace type { STR = MSGPACK_OBJECT_STR, BIN = MSGPACK_OBJECT_BIN, ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP + MAP = MSGPACK_OBJECT_MAP, + EXT = MSGPACK_OBJECT_EXT }; } @@ -71,6 +72,13 @@ struct object_bin { const char* ptr; }; +struct object_ext { + int8_t type() const { return ptr[0]; } + const char* data() const { return &ptr[1]; } + uint32_t size; + const char* ptr; +}; + struct object { union union_type { bool boolean; @@ -81,6 +89,7 @@ struct object { object_map map; object_str str; object_bin bin; + object_ext ext; }; type::object_type type; @@ -242,6 +251,10 @@ inline bool operator==(const object& x, const object& y) return x.via.bin.size == y.via.bin.size && memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + case type::EXT: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + case type::ARRAY: if(x.via.array.size != y.via.array.size) { return false; @@ -444,6 +457,11 @@ packer& operator<< (packer& o, const object& v) o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); return o; + case type::EXT: + o.pack_ext(v.via.ext.size, v.via.ext.type()); + o.pack_ext_body(v.via.ext.data(), v.via.ext.size); + return o; + case type::ARRAY: o.pack_array(v.via.array.size); for(object* p(v.via.array.ptr), diff --git a/include/msgpack/pack.hpp b/include/msgpack/pack.hpp index 47958af3..bfae2dd2 100644 --- a/include/msgpack/pack.hpp +++ b/include/msgpack/pack.hpp @@ -84,6 +84,9 @@ public: packer& pack_bin(size_t l); packer& pack_bin_body(const char* b, size_t l); + packer& pack_ext(size_t l, int8_t type); + packer& pack_ext_body(const char* b, size_t l); + private: template void pack_imp_uint8(T d); @@ -699,6 +702,72 @@ inline packer& packer::pack_bin_body(const char* b, size_t l) return *this; } +template +inline packer& packer::pack_ext(size_t l, int8_t type) +{ + switch(l) { + case 1: { + char buf[2]; + buf[0] = static_cast(0xd4); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 2: { + char buf[2]; + buf[0] = static_cast(0xd5); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 4: { + char buf[2]; + buf[0] = static_cast(0xd6); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 8: { + char buf[2]; + buf[0] = static_cast(0xd7); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + case 16: { + char buf[2]; + buf[0] = static_cast(0xd8); + buf[1] = static_cast(type); + append_buffer(buf, 2); + } break; + default: + if(l < 256) { + char buf[3]; + buf[0] = static_cast(0xc7); + buf[1] = static_cast(l); + buf[2] = static_cast(type); + append_buffer(buf, 3); + } else if(l < 65536) { + char buf[4]; + buf[0] = static_cast(0xc8); + _msgpack_store16(&buf[1], static_cast(l)); + buf[3] = static_cast(type); + append_buffer(buf, 4); + } else { + char buf[6]; + buf[0] = static_cast(0xc9); + _msgpack_store32(&buf[1], static_cast(l)); + buf[5] = static_cast(type); + append_buffer(buf, 6); + } + break; + } + return *this; +} + +template +inline packer& packer::pack_ext_body(const char* b, size_t l) +{ + append_buffer(b, l); + return *this; +} + template template inline void packer::pack_imp_uint8(T d) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index e3c7a535..311a107a 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -17,7 +17,6 @@ // #ifndef MSGPACK_UNPACK_HPP #define MSGPACK_UNPACK_HPP - #include "object.hpp" #include "zone.hpp" #include "unpack_define.h" @@ -48,18 +47,26 @@ namespace msgpack { +typedef bool (*unpack_reference_func)(type::object_type, uint64_t, void*); + namespace detail { class unpack_user { public: + unpack_user(unpack_reference_func f = nullptr, void* user_data = nullptr) + :m_func(f), m_user_data(user_data) {} msgpack::zone const& zone() const { return *m_zone; } msgpack::zone& zone() { return *m_zone; } void set_zone(msgpack::zone& zone) { m_zone = &zone; } bool referenced() const { return m_referenced; } void set_referenced(bool referenced) { m_referenced = referenced; } + unpack_reference_func reference_func() const { return m_func; } + void* user_data() const { return m_user_data; } private: msgpack::zone* m_zone; bool m_referenced; + unpack_reference_func m_func; + void* m_user_data; }; inline void unpack_uint8(uint8_t d, object& o) @@ -106,7 +113,7 @@ inline void unpack_false(object& o) { o.type = type::BOOLEAN; o.via.boolean = false; } struct unpack_array { - void operator()(unpack_user&u, unsigned int n, object& o) const { + void operator()(unpack_user& u, uint32_t n, object& o) const { o.type = type::ARRAY; o.via.array.size = 0; o.via.array.ptr = static_cast(u.zone().allocate_align(n*sizeof(object))); @@ -116,14 +123,14 @@ struct unpack_array { inline void unpack_array_item(object& c, object const& o) { #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object)); + std::memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(object)); #else /* __GNUC__ && !__clang__ */ c.via.array.ptr[c.via.array.size++] = o; #endif /* __GNUC__ && !__clang__ */ } struct unpack_map { - void operator()(unpack_user& u, unsigned int n, object& o) const { + void operator()(unpack_user& u, uint32_t n, object& o) const { o.type = type::MAP; o.via.map.size = 0; o.via.map.ptr = static_cast(u.zone().allocate_align(n*sizeof(object_kv))); @@ -133,8 +140,8 @@ struct unpack_map { inline void unpack_map_item(object& c, object const& k, object const& v) { #if defined(__GNUC__) && !defined(__clang__) - memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object)); - memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(object)); + std::memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(object)); + std::memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(object)); #else /* __GNUC__ && !__clang__ */ c.via.map.ptr[c.via.map.size].key = k; c.via.map.ptr[c.via.map.size].val = v; @@ -142,20 +149,49 @@ inline void unpack_map_item(object& c, object const& k, object const& v) ++c.via.map.size; } -inline void unpack_str(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) +inline void unpack_str(unpack_user& u, const char* b, const char* p, uint64_t l, object& o) { o.type = type::STR; - o.via.str.ptr = p; + if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { + o.via.str.ptr = p; + u.set_referenced(true); + } + else { + char* tmp = static_cast(u.zone().allocate_align(l)); + std::memcpy(tmp, p, l); + o.via.str.ptr = tmp; + } o.via.str.size = l; - u.set_referenced(true); } -inline void unpack_bin(unpack_user& u, const char* b, const char* p, unsigned int l, object& o) +inline void unpack_bin(unpack_user& u, const char* b, const char* p, uint64_t l, object& o) { o.type = type::BIN; - o.via.bin.ptr = p; + if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { + o.via.bin.ptr = p; + u.set_referenced(true); + } + else { + char* tmp = static_cast(u.zone().allocate_align(l)); + std::memcpy(tmp, p, l); + o.via.bin.ptr = tmp; + } o.via.bin.size = l; - u.set_referenced(true); +} + +inline void unpack_ext(unpack_user& u, const char* p, uint64_t l, object& o) +{ + o.type = type::EXT; + if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { + o.via.ext.ptr = p; + u.set_referenced(true); + } + else { + char* tmp = static_cast(u.zone().allocate_align(l)); + std::memcpy(tmp, p, l); + o.via.ext.ptr = tmp; + } + o.via.ext.size = l - 1; } @@ -167,14 +203,14 @@ public: std::size_t count() const { return m_count; } void set_count(std::size_t count) { m_count = count; } std::size_t decl_count() { return --m_count; } - unsigned int container_type() const { return m_container_type; } - void set_container_type(unsigned int container_type) { m_container_type = container_type; } + uint32_t container_type() const { return m_container_type; } + void set_container_type(uint32_t container_type) { m_container_type = container_type; } object const& map_key() const { return m_map_key; } void set_map_key(object const& map_key) { m_map_key = map_key; } private: object m_obj; std::size_t m_count; - unsigned int m_container_type; + uint32_t m_container_type; object m_map_key; }; @@ -210,12 +246,12 @@ struct value { }; template <> struct value { - typedef unsigned int type; + typedef uint32_t type; }; template -inline void load(unsigned int& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - dst = static_cast(*reinterpret_cast(n)) & 0x0f; +inline void load(uint32_t& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { + dst = static_cast(*reinterpret_cast(n)) & 0x0f; } template @@ -240,7 +276,7 @@ inline void load(T& dst, const char* n, typename msgpack::enable_if(*m_current) & 0x03); + m_trail = 1 << (static_cast(*m_current) & 0x03); + m_cs = next_cs(m_current); + fixed_trail_again = true; + break; + + case 0xc7: // ext 8 + case 0xc8: // ext 16 + case 0xc9: // ext 32 + m_trail = 1 << ((static_cast(*m_current) + 1) & 0x03); m_cs = next_cs(m_current); fixed_trail_again = true; break; - //case 0xc7: - //case 0xc8: - //case 0xc9: case 0xca: // float case 0xcb: // double case 0xcc: // unsigned int 8 @@ -337,36 +381,49 @@ public: case 0xd1: // signed int 16 case 0xd2: // signed int 32 case 0xd3: // signed int 64 - m_trail = 1 << (static_cast(*m_current) & 0x03); + m_trail = 1 << (static_cast(*m_current) & 0x03); m_cs = next_cs(m_current); fixed_trail_again = true; break; - //case 0xd4: - //case 0xd5: - //case 0xd6: // big integer 16 - //case 0xd7: // big integer 32 - //case 0xd8: // big float 16 + + case 0xd4: // fixext 1 + case 0xd5: // fixext 2 + case 0xd6: // fixext 4 + case 0xd7: // fixext 8 + m_trail = (1 << (static_cast(*m_current) & 0x03)) + 1; + m_cs = next_cs(m_current); + fixed_trail_again = true; + break; + + case 0xd8: // fixext 16 + m_trail = 17; + m_cs = next_cs(m_current); + fixed_trail_again = true; + break; + case 0xd9: // str 8 case 0xda: // str 16 case 0xdb: // str 32 - m_trail = 1 << ((static_cast(*m_current) & 0x03) - 1); + m_trail = 1 << ((static_cast(*m_current) & 0x03) - 1); m_cs = next_cs(m_current); fixed_trail_again = true; break; + case 0xdc: // array 16 case 0xdd: // array 32 case 0xde: // map 16 case 0xdf: // map 32 - m_trail = 2 << (static_cast(*m_current) & 0x01); + m_trail = 2 << (static_cast(*m_current) & 0x01); m_cs = next_cs(m_current); fixed_trail_again = true; break; + default: off = m_current - m_start; return -1; } } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr - m_trail = static_cast(*m_current) & 0x1f; + m_trail = static_cast(*m_current) & 0x1f; if(m_trail == 0) { unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); @@ -479,6 +536,31 @@ public: int ret = push_proc(obj, off); if (ret != 0) return ret; } break; + case CS_FIXEXT_1: { + unpack_ext(m_user, n, 1+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_2: { + unpack_ext(m_user, n, 2+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_4: { + unpack_ext(m_user, n, 4+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_8: { + unpack_ext(m_user, n, 8+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; + case CS_FIXEXT_16: { + unpack_ext(m_user, n, 16+1, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; case CS_STR_8: { uint8_t tmp; load(tmp, n); @@ -507,6 +589,20 @@ public: fixed_trail_again = true; } } break; + case CS_EXT_8: { + uint8_t tmp; + load(tmp, n); + m_trail = tmp + 1; + if(m_trail == 0) { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_EXT_VALUE; + fixed_trail_again = true; + } + } break; case CS_STR_16: { uint16_t tmp; load(tmp, n); @@ -535,8 +631,24 @@ public: fixed_trail_again = true; } } break; - case CS_STR_32: - load(m_trail, n); + case CS_EXT_16: { + uint16_t tmp; + load(tmp, n); + m_trail = tmp + 1; + if(m_trail == 0) { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_EXT_VALUE; + fixed_trail_again = true; + } + } break; + case CS_STR_32: { + uint32_t tmp; + load(tmp, n); + m_trail = tmp; if(m_trail == 0) { unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); @@ -546,9 +658,11 @@ public: m_cs = ACS_STR_VALUE; fixed_trail_again = true; } - break; - case CS_BIN_32: - load(m_trail, n); + } break; + case CS_BIN_32: { + uint32_t tmp; + load(tmp, n); + m_trail = tmp; if(m_trail == 0) { unpack_bin(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); @@ -558,7 +672,21 @@ public: m_cs = ACS_BIN_VALUE; fixed_trail_again = true; } - break; + } break; + case CS_EXT_32: { + uint32_t tmp; + load(tmp, n); + m_trail = tmp + 1; + if(m_trail == 0) { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } + else { + m_cs = ACS_EXT_VALUE; + fixed_trail_again = true; + } + } break; case ACS_STR_VALUE: { unpack_str(m_user, data, n, m_trail, obj); int ret = push_proc(obj, off); @@ -569,6 +697,11 @@ public: int ret = push_proc(obj, off); if (ret != 0) return ret; } break; + case ACS_EXT_VALUE: { + unpack_ext(m_user, n, m_trail, obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } break; case CS_ARRAY_16: { int ret = push_aggregate( unpack_array(), CT_ARRAY_ITEM, obj, n, off); @@ -604,15 +737,15 @@ public: private: template - static unsigned int next_cs(T p) + static uint32_t next_cs(T p) { - return static_cast(*p) & 0x1f; + return static_cast(*p) & 0x1f; } template int push_aggregate( Func const& f, - unsigned int container_type, + uint32_t container_type, object& obj, const char* load_pos, std::size_t& off) { @@ -706,11 +839,11 @@ private: char const* m_start; char const* m_current; - unsigned int m_trail; + uint64_t m_trail; unpack_user m_user; - unsigned int m_cs; - unsigned int m_top; - unsigned int m_stack_idx; + uint32_t m_cs; + uint32_t m_top; + uint32_t m_stack_idx; unpack_stack m_stack[MSGPACK_EMBED_STACK_SIZE]; }; @@ -730,7 +863,7 @@ struct unpack_error : public std::runtime_error { class unpacked { public: - unpacked() { } + unpacked():m_referenced(false) { } unpacked(object const& obj, msgpack::unique_ptr z) : m_obj(obj), m_zone(msgpack::move(z)) { } @@ -747,15 +880,24 @@ public: const msgpack::unique_ptr& zone() const { return m_zone; } + void set_referenced(bool r) + { m_referenced = r; } + + bool referenced() const + { return m_referenced; } + private: object m_obj; msgpack::unique_ptr m_zone; + bool m_referenced; }; class unpacker { public: - unpacker(std::size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + unpacker(unpack_reference_func f = &unpacker::default_reference_func, + void* user_data = nullptr, + std::size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE); #if !defined(MSGPACK_USE_CPP03) unpacker(unpacker&& other); @@ -854,6 +996,7 @@ private: void expand_buffer(std::size_t size); int execute_imp(); bool flush_zone(); + static bool default_reference_func(type::object_type type, uint64_t len, void*); private: char* m_buffer; @@ -871,14 +1014,19 @@ private: }; inline void unpack(unpacked& result, - const char* data, std::size_t len, std::size_t& off); + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f = nullptr, void* user_data = nullptr); inline void unpack(unpacked& result, - const char* data, std::size_t len); -// obsolete -inline void unpack(unpacked* result, - const char* data, std::size_t len, std::size_t* off = nullptr); + const char* data, std::size_t len, + unpack_reference_func f = nullptr, void* user_data = nullptr); // obsolete +inline void unpack(unpacked* result, + const char* data, std::size_t len, std::size_t* off = nullptr, + unpack_reference_func f = nullptr, void* user_data = nullptr); + + +// for internal use typedef enum { UNPACK_SUCCESS = 2, UNPACK_EXTRA_BYTES = 1, @@ -886,22 +1034,10 @@ typedef enum { UNPACK_PARSE_ERROR = -1 } unpack_return; -// obsolete -static unpack_return unpack(const char* data, std::size_t len, std::size_t& off, - zone& z, object& result); -static unpack_return unpack(const char* data, std::size_t len, - zone& z, object& result); -static unpack_return unpack(const char* data, std::size_t len, std::size_t* off, - zone* z, object* result); - - -// obsolete -static object unpack(const char* data, std::size_t len, zone& z, std::size_t& off); -static object unpack(const char* data, std::size_t len, zone& z); -static object unpack(const char* data, std::size_t len, zone* z, std::size_t* off = nullptr); - - -inline unpacker::unpacker(std::size_t initial_buffer_size) +inline unpacker::unpacker(unpack_reference_func f, + void* user_data, + std::size_t initial_buffer_size) + :m_ctx(f, user_data) { if(initial_buffer_size < COUNTER_SIZE) { initial_buffer_size = COUNTER_SIZE; @@ -1012,7 +1148,7 @@ inline void unpacker::expand_buffer(std::size_t size) detail::init_count(tmp); - ::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); + std::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); if(m_ctx.user().referenced()) { try { @@ -1066,6 +1202,7 @@ inline bool unpacker::next(unpacked& result) } else { result.zone().reset( release_zone() ); result.set(data()); + result.set_referenced(m_ctx.user().referenced()); reset(); return true; } @@ -1184,7 +1321,8 @@ namespace detail { inline unpack_return unpack_imp(const char* data, std::size_t len, std::size_t& off, - zone& result_zone, object& result) + zone& result_zone, object& result, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr) { std::size_t noff = off; @@ -1193,17 +1331,19 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off, return UNPACK_CONTINUE; } - detail::context ctx; + detail::context ctx(f, user_data); ctx.init(); ctx.user().set_zone(result_zone); ctx.user().set_referenced(false); + referenced = false; int e = ctx.execute(data, len, noff); if(e < 0) { return UNPACK_PARSE_ERROR; } + referenced = ctx.user().referenced(); off = noff; if(e == 0) { @@ -1223,29 +1363,28 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off, // reference version inline void unpack(unpacked& result, - const char* data, std::size_t len, std::size_t& off) + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f, void* user_data) { object obj; msgpack::unique_ptr z(new zone()); - + bool referenced = false; unpack_return ret = detail::unpack_imp( - data, len, off, *z, obj); + data, len, off, *z, obj, referenced); + result.set_referenced(referenced); switch(ret) { case UNPACK_SUCCESS: result.set(obj); result.zone() = msgpack::move(z); return; - case UNPACK_EXTRA_BYTES: result.set(obj); result.zone() = msgpack::move(z); return; - case UNPACK_CONTINUE: throw unpack_error("insufficient bytes"); - case UNPACK_PARSE_ERROR: default: throw unpack_error("parse error"); @@ -1253,88 +1392,29 @@ inline void unpack(unpacked& result, } inline void unpack(unpacked& result, - const char* data, std::size_t len) + const char* data, std::size_t len, + unpack_reference_func f, void* user_data) { std::size_t off = 0; - return unpack(result, data, len, off); + unpack(result, data, len, off, f, user_data); } // obsolete // pointer version inline void unpack(unpacked* result, - const char* data, std::size_t len, std::size_t* off) { + const char* data, std::size_t len, std::size_t* off, + unpack_reference_func f, void* user_data) +{ if (off) unpack(*result, data, len, *off); - else unpack(*result, data, len); + else unpack(*result, data, len, f, user_data); } - -// obsolete -// reference version -inline unpack_return unpack(const char* data, std::size_t len, std::size_t& off, - zone& z, object& result) +bool unpacker::default_reference_func(type::object_type type, uint64_t len, void*) { - return detail::unpack_imp(data, len, off, z, result); -} - -// obsolete -inline unpack_return unpack(const char* data, std::size_t len, - zone& z, object& result) -{ - std::size_t off = 0; - return detail::unpack_imp(data, len, off, z, result); -} - -// obsolete -// pointer version -inline unpack_return unpack(const char* data, std::size_t len, std::size_t* off, - zone* z, object* result) -{ - if (off) return unpack(data, len, *off, *z, *result); - else return unpack(data, len, *z, *result); -} - -// obsolete -// reference version -inline object unpack(const char* data, std::size_t len, zone& z, std::size_t& off) -{ - object result; - - switch( unpack(data, len, off, z, result) ) { - case UNPACK_SUCCESS: - return result; - - case UNPACK_EXTRA_BYTES: - if(off) { - return result; - } else { - throw unpack_error("extra bytes"); - } - - case UNPACK_CONTINUE: - throw unpack_error("insufficient bytes"); - - case UNPACK_PARSE_ERROR: - default: - throw unpack_error("parse error"); - } -} - -// obsolete -inline object unpack(const char* data, std::size_t len, zone& z) -{ - std::size_t off = 0; - return unpack(data, len, z, off); -} - - -// obsolete -// pointer version -inline object unpack(const char* data, std::size_t len, zone* z, std::size_t* off) -{ - if (off) return unpack(data, len, *z, *off); - else return unpack(data, len, *z); + return true; } } // namespace msgpack + #endif /* msgpack/unpack.hpp */ diff --git a/include/msgpack/unpack_define.h b/include/msgpack/unpack_define.h index 182137f8..d37183d3 100644 --- a/include/msgpack/unpack_define.h +++ b/include/msgpack/unpack_define.h @@ -45,9 +45,9 @@ typedef enum { CS_BIN_16 = 0x05, CS_BIN_32 = 0x06, - //CS_EXT_8 = 0x07, - //CS_EXT_16 = 0x08, - //CS_EXT_32 = 0x09, + CS_EXT_8 = 0x07, + CS_EXT_16 = 0x08, + CS_EXT_32 = 0x09, CS_FLOAT = 0x0a, CS_DOUBLE = 0x0b, @@ -60,11 +60,11 @@ typedef enum { CS_INT_32 = 0x12, CS_INT_64 = 0x13, - //CS_FIXEXT_1 = 0x14, - //CS_FIXEXT_2 = 0x15, - //CS_FIXEXT_4 = 0x16, - //CS_FIXEXT_8 = 0x17, - //CS_FIXEXT_16 = 0x18, + CS_FIXEXT_1 = 0x14, + CS_FIXEXT_2 = 0x15, + CS_FIXEXT_4 = 0x16, + CS_FIXEXT_8 = 0x17, + CS_FIXEXT_16 = 0x18, CS_STR_8 = 0x19, // str8 CS_STR_16 = 0x1a, // str16 @@ -77,7 +77,8 @@ typedef enum { //ACS_BIG_INT_VALUE, //ACS_BIG_FLOAT_VALUE, ACS_STR_VALUE, - ACS_BIN_VALUE + ACS_BIN_VALUE, + ACS_EXT_VALUE } msgpack_unpack_state; diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index e678385f..8dda3f39 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -274,6 +274,170 @@ TEST(MSGPACK, simple_buffer_false) EXPECT_EQ(val1, val2); } +TEST(MSGPACK, simple_buffer_fixext1) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_EQ(2, ret.get().via.ext.data()[0]); +} + +TEST(MSGPACK, simple_buffer_fixext2) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3 }; + + packer.pack_ext(sizeof(buf), 0); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(2, ret.get().via.ext.size); + EXPECT_EQ(0, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext4) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(4, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext8) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(8, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext16) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(16, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_0) +{ + std::size_t const size = 0; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + + packer.pack_ext(size, 77); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_255) +{ + std::size_t const size = 255; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_256) +{ + std::size_t const size = 256; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_65535) +{ + std::size_t const size = 65535; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_4byte_65536) +{ + std::size_t const size = 65536; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + //----------------------------------------------------------------------------- // STL @@ -707,16 +871,9 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) TestClass val1; msgpack::sbuffer sbuf; msgpack::pack(sbuf, val1); - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret); - TestClass2 val2; - val2.i = -1; - val2.s = ""; - val2.v = vector(); - obj.convert(&val2); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass2 val2 = ret.get().as(); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc index 7f2afd45..b95bccde 100644 --- a/test/pack_unpack.cc +++ b/test/pack_unpack.cc @@ -49,88 +49,6 @@ TEST(pack, myclass) msgpack::pack(sbuf, m); } - -TEST(unpack, myclass_no_offset) -{ - msgpack::sbuffer sbuf; - myclass m1(1, "phraser"); - msgpack::pack(sbuf, m1); - - msgpack::zone z; - msgpack::object obj; - - // obsolete - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - - myclass m2 = obj.as(); - EXPECT_EQ(m1.num, m2.num); - EXPECT_EQ(m1.str, m2.str); -} - -TEST(unpack, myclass_offset) -{ - msgpack::sbuffer sbuf; - myclass m1(1, "phraser"); - msgpack::pack(sbuf, m1); - - msgpack::zone z; - msgpack::object obj; - std::size_t off = 0; - // obsolete - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); - - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - - myclass m2 = obj.as(); - EXPECT_EQ(m1.num, m2.num); - EXPECT_EQ(m1.str, m2.str); - EXPECT_EQ(off, sbuf.size()); -} - -TEST(unpack, myclass_offset_pointer) -{ - msgpack::sbuffer sbuf; - myclass m1(1, "phraser"); - msgpack::pack(sbuf, m1); - - msgpack::zone z; - msgpack::object obj; - std::size_t off = 0; - // obsolete - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj); - - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - - myclass m2 = obj.as(); - EXPECT_EQ(m1.num, m2.num); - EXPECT_EQ(m1.str, m2.str); - EXPECT_EQ(off, sbuf.size()); -} - -TEST(unpack, myclass_offset_null_pointer) -{ - msgpack::sbuffer sbuf; - myclass m1(1, "phraser"); - msgpack::pack(sbuf, m1); - - msgpack::zone z; - msgpack::object obj; - // obsolete - msgpack::unpack_return ret = - msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj); - - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - - myclass m2 = obj.as(); - EXPECT_EQ(m1.num, m2.num); - EXPECT_EQ(m1.str, m2.str); -} - TEST(unpack, int_no_offset) { msgpack::sbuffer sbuf; @@ -212,106 +130,3 @@ TEST(unpack, sequence) EXPECT_EQ(off, sbuf.size()); } - -TEST(unpack_return, int_no_offset) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret; - - // obsolete - ret = msgpack::unpack(sbuf.data(), sbuf.size(), z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - EXPECT_EQ(1, obj.as()); -} - -TEST(unpack_return, int_offset) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - - std::size_t off = 0; - - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret; - - // obsolete - ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(off, sbuf.size()); -} - -TEST(unpack_return, int_pointer) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - - std::size_t off = 0; - - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret; - - // obsolete - ret = msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(off, sbuf.size()); -} - -TEST(unpack_return, int_null_pointer) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret; - - // obsolete - ret = msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - EXPECT_EQ(1, obj.as()); -} - - -TEST(unpack, sequence_compat) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::pack(sbuf, 2); - msgpack::pack(sbuf, 3); - - std::size_t off = 0; - - msgpack::zone z; - msgpack::object obj; - msgpack::unpack_return ret; - - // obsolete - ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); - EXPECT_EQ(1, obj.as()); - - // obsolete - ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES); - EXPECT_EQ(2, obj.as()); - - // obsolete - ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj); - EXPECT_TRUE(ret >= 0); - EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS); - EXPECT_EQ(3, obj.as()); -} From 7822bc787d5aeff7a22ea7f6d72415b102f74519 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 7 Aug 2014 10:28:18 +0900 Subject: [PATCH 103/153] Replaced switch-case and bit calculation with a table. --- include/msgpack/unpack.hpp | 107 +++++++++++++------------------------ 1 file changed, 37 insertions(+), 70 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 311a107a..c68fa210 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -325,8 +325,7 @@ public: if (m_cs == CS_HEADER) { fixed_trail_again = false; int selector = *reinterpret_cast(m_current); - if (0) { - } else if(0x00 <= selector && selector <= 0x7f) { // Positive Fixnum + if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum unpack_uint8(*reinterpret_cast(m_current), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; @@ -334,7 +333,7 @@ public: unpack_int8(*reinterpret_cast(m_current), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; - } else if(0xc0 <= selector && selector <= 0xdf) { // Variable + } else if(0xc0 <= selector && selector <= 0xc3) { // nil, bool switch(selector) { case 0xc0: { // nil unpack_nil(obj); @@ -354,74 +353,42 @@ public: int ret = push_proc(obj, off); if (ret != 0) return ret; } break; - - case 0xc4: // bin 8 - case 0xc5: // bin 16 - case 0xc6: // bin 32 - m_trail = 1 << (static_cast(*m_current) & 0x03); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - - case 0xc7: // ext 8 - case 0xc8: // ext 16 - case 0xc9: // ext 32 - m_trail = 1 << ((static_cast(*m_current) + 1) & 0x03); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - - case 0xca: // float - case 0xcb: // double - case 0xcc: // unsigned int 8 - case 0xcd: // unsigned int 16 - case 0xce: // unsigned int 32 - case 0xcf: // unsigned int 64 - case 0xd0: // signed int 8 - case 0xd1: // signed int 16 - case 0xd2: // signed int 32 - case 0xd3: // signed int 64 - m_trail = 1 << (static_cast(*m_current) & 0x03); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - - case 0xd4: // fixext 1 - case 0xd5: // fixext 2 - case 0xd6: // fixext 4 - case 0xd7: // fixext 8 - m_trail = (1 << (static_cast(*m_current) & 0x03)) + 1; - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - - case 0xd8: // fixext 16 - m_trail = 17; - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - - case 0xd9: // str 8 - case 0xda: // str 16 - case 0xdb: // str 32 - m_trail = 1 << ((static_cast(*m_current) & 0x03) - 1); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - - case 0xdc: // array 16 - case 0xdd: // array 32 - case 0xde: // map 16 - case 0xdf: // map 32 - m_trail = 2 << (static_cast(*m_current) & 0x01); - m_cs = next_cs(m_current); - fixed_trail_again = true; - break; - - default: - off = m_current - m_start; - return -1; } + } + else if (0xc4 <= selector && selector <= 0xdf) { + const uint32_t trail[] = { + 1, // bin 8 0xc4 + 2, // bin 16 0xc5 + 4, // bin 32 0xc6 + 1, // ext 8 0xc7 + 2, // ext 16 0xc8 + 4, // ext 32 0xc9 + 4, // float 32 0xca + 8, // float 64 0xcb + 1, // uint 8 0xcc + 2, // uint 16 0xcd + 4, // uint 32 0xce + 8, // uint 64 0xcf + 1, // int 8 0xd0 + 2, // int 16 0xd1 + 4, // int 32 0xd2 + 8, // int 64 0xd3 + 2, // fixext 1 0xd4 + 3, // fixext 2 0xd5 + 5, // fixext 4 0xd6 + 9, // fixext 8 0xd7 + 17,// fixext 16 0xd8 + 1, // str 8 0xd9 + 2, // str 16 0xda + 4, // str 32 0xdb + 2, // array 16 0xdc + 4, // array 32 0xdd + 2, // map 16 0xde + 4, // map 32 0xdf + }; + m_trail = trail[selector - 0xc4]; + m_cs = next_cs(m_current); + fixed_trail_again = true; } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr m_trail = static_cast(*m_current) & 0x1f; if(m_trail == 0) { From b5b459cfca904f617bde6295eeb4ca77f78e9f00 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 7 Aug 2014 10:40:21 +0900 Subject: [PATCH 104/153] Reordered unpack selector sequence. --- include/msgpack/unpack.hpp | 36 +++++++++++++----------------------- 1 file changed, 13 insertions(+), 23 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index c68fa210..0c467384 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -333,29 +333,7 @@ public: unpack_int8(*reinterpret_cast(m_current), obj); int ret = push_proc(obj, off); if (ret != 0) return ret; - } else if(0xc0 <= selector && selector <= 0xc3) { // nil, bool - switch(selector) { - case 0xc0: { // nil - unpack_nil(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - - //case 0xc1: // string - case 0xc2: { // false - unpack_false(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - - case 0xc3: { // true - unpack_true(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - } - } - else if (0xc4 <= selector && selector <= 0xdf) { + } else if (0xc4 <= selector && selector <= 0xdf) { const uint32_t trail[] = { 1, // bin 8 0xc4 2, // bin 16 0xc5 @@ -409,6 +387,18 @@ public: int ret = push_aggregate( unpack_map(), CT_MAP_KEY, obj, m_current, off); if (ret != 0) return ret; + } else if(selector == 0xc2) { // false + unpack_false(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if(selector == 0xc3) { // true + unpack_true(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; + } else if(selector == 0xc0) { // nil + unpack_nil(obj); + int ret = push_proc(obj, off); + if (ret != 0) return ret; } else { off = m_current - m_start; return -1; From 17e696fc0d0eae454d50e0b5b858d7a3c89cfc49 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 7 Aug 2014 15:23:34 +0900 Subject: [PATCH 105/153] Removed redundant memory allocation from zone. Removed zone::create and zone::destroy. We can use zone as follows: zone z; // on stack zone* z = new zone; // on heap Fixed a resource leak when zone::push_finalizer(msgpack::unique_ptr) is called. --- erb/cpp03_zone.hpp.erb | 47 +++++---------- include/msgpack/detail/cpp03_zone.hpp | 77 ++++++++++-------------- include/msgpack/detail/cpp11_zone.hpp | 86 +++++++++++++++++---------- include/msgpack/unpack.hpp | 27 +++------ src/zone.c | 2 +- 5 files changed, 111 insertions(+), 128 deletions(-) diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index 212c315f..da1656f5 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -114,14 +114,10 @@ class zone { ~chunk_list() { chunk* c = m_head; - while(true) { + while(c) { chunk* n = c->m_next; ::free(c); - if(n) { - c = n; - } else { - break; - } + c = n; } } void clear(size_t chunk_size) @@ -152,8 +148,6 @@ public: zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; public: - static zone* create(size_t chunk_size); - static void destroy(zone* zone); void* allocate_align(size_t size); void* allocate_no_align(size_t size); @@ -192,28 +186,14 @@ private: void undo_allocate(size_t size); template - static void object_destructor(void* obj); + static void object_destruct(void* obj); + + template + static void object_delete(void* obj); void* allocate_expand(size_t size); }; - -inline zone* zone::create(size_t chunk_size) -{ - zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); - if (!z) { - throw std::bad_alloc(); - } - new (z) zone(chunk_size); - return z; -} - -inline void zone::destroy(zone* z) -{ - z->~zone(); - ::free(z); -} - inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } @@ -268,8 +248,7 @@ inline void zone::push_finalizer(void (*func)(void*), void* data) template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - m_finalizer_array.push(&zone::object_destructor, obj.get()); - obj.release(); + m_finalizer_array.push(&zone::object_delete, obj.release()); } inline void zone::clear() @@ -284,9 +263,15 @@ inline void zone::swap(zone& o) } template -void zone::object_destructor(void* obj) +void zone::object_destruct(void* obj) { - reinterpret_cast(obj)->~T(); + static_cast(obj)->~T(); +} + +template +void zone::object_delete(void* obj) +{ + delete static_cast(obj); } inline void zone::undo_allocate(size_t size) @@ -301,7 +286,7 @@ T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index 143402f3..989398da 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -114,14 +114,10 @@ class zone { ~chunk_list() { chunk* c = m_head; - while(true) { + while(c) { chunk* n = c->m_next; ::free(c); - if(n) { - c = n; - } else { - break; - } + c = n; } } void clear(size_t chunk_size) @@ -152,8 +148,6 @@ public: zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; public: - static zone* create(size_t chunk_size); - static void destroy(zone* zone); void* allocate_align(size_t size); void* allocate_no_align(size_t size); @@ -237,28 +231,14 @@ private: void undo_allocate(size_t size); template - static void object_destructor(void* obj); + static void object_destruct(void* obj); + + template + static void object_delete(void* obj); void* allocate_expand(size_t size); }; - -inline zone* zone::create(size_t chunk_size) -{ - zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); - if (!z) { - throw std::bad_alloc(); - } - new (z) zone(chunk_size); - return z; -} - -inline void zone::destroy(zone* z) -{ - z->~zone(); - ::free(z); -} - inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } @@ -313,8 +293,7 @@ inline void zone::push_finalizer(void (*func)(void*), void* data) template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - m_finalizer_array.push(&zone::object_destructor, obj.get()); - obj.release(); + m_finalizer_array.push(&zone::object_delete, obj.release()); } inline void zone::clear() @@ -329,9 +308,15 @@ inline void zone::swap(zone& o) } template -void zone::object_destructor(void* obj) +void zone::object_destruct(void* obj) { - reinterpret_cast(obj)->~T(); + static_cast(obj)->~T(); +} + +template +void zone::object_delete(void* obj) +{ + delete static_cast(obj); } inline void zone::undo_allocate(size_t size) @@ -346,7 +331,7 @@ T* zone::allocate() { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -365,7 +350,7 @@ T* zone::allocate(A1 a1) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -384,7 +369,7 @@ T* zone::allocate(A1 a1, A2 a2) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -403,7 +388,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -422,7 +407,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -441,7 +426,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -460,7 +445,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -479,7 +464,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -498,7 +483,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -517,7 +502,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -536,7 +521,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -555,7 +540,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -574,7 +559,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -593,7 +578,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -612,7 +597,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; @@ -631,7 +616,7 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; diff --git a/include/msgpack/detail/cpp11_zone.hpp b/include/msgpack/detail/cpp11_zone.hpp index 7ea92863..574ee8c7 100644 --- a/include/msgpack/detail/cpp11_zone.hpp +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -91,9 +91,28 @@ private: ++m_tail; } +#if !defined(MSGPACK_USE_CPP03) + finalizer_array(finalizer_array&& other) + :m_tail(other.m_tail), m_end(other.m_end), m_array(other.m_array) + { + other.m_tail = nullptr; + other.m_end = nullptr; + other.m_array = nullptr; + } + finalizer_array& operator=(finalizer_array&& other) + { + this->~finalizer_array(); + new (this) finalizer_array(std::move(other)); + return *this; + } +#endif finalizer* m_tail; finalizer* m_end; finalizer* m_array; + + private: + finalizer_array(const finalizer_array&); + finalizer_array& operator=(const finalizer_array&); }; struct chunk { chunk* m_next; @@ -114,14 +133,10 @@ private: ~chunk_list() { chunk* c = m_head; - while(true) { + while(c) { chunk* n = c->m_next; ::free(c); - if(n) { - c = n; - } else { - break; - } + c = n; } } void clear(size_t chunk_size) @@ -141,9 +156,25 @@ private: m_free = chunk_size; m_ptr = reinterpret_cast(m_head) + sizeof(chunk); } +#if !defined(MSGPACK_USE_CPP03) + chunk_list(chunk_list&& other) + :m_free(other.m_free), m_ptr(other.m_ptr), m_head(other.m_head) + { + other.m_head = nullptr; + } + chunk_list& operator=(chunk_list&& other) + { + this->~chunk_list(); + new (this) chunk_list(std::move(other)); + return *this; + } +#endif size_t m_free; char* m_ptr; chunk* m_head; + private: + chunk_list(const chunk_list&); + chunk_list& operator=(const chunk_list&); }; size_t m_chunk_size; chunk_list m_chunk_list; @@ -153,8 +184,6 @@ public: zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; public: - static zone* create(size_t chunk_size); - static void destroy(zone* zone); void* allocate_align(size_t size); void* allocate_no_align(size_t size); @@ -189,31 +218,23 @@ public: template T* allocate(Args... args); + zone(zone&&) = default; + zone& operator=(zone&&) = default; + private: void undo_allocate(size_t size); + zone(const zone&); + zone& operator=(const zone&); template - static void object_destructor(void* obj); + static void object_destruct(void* obj); + + template + static void object_delete(void* obj); void* allocate_expand(size_t size); }; -inline zone* zone::create(size_t chunk_size) -{ - zone* z = static_cast(::malloc(sizeof(zone) + chunk_size)); - if (!z) { - throw std::bad_alloc(); - } - new (z) zone(chunk_size); - return z; -} - -inline void zone::destroy(zone* z) -{ - z->~zone(); - ::free(z); -} - inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) { } @@ -268,8 +289,7 @@ inline void zone::push_finalizer(void (*func)(void*), void* data) template inline void zone::push_finalizer(msgpack::unique_ptr obj) { - m_finalizer_array.push(&zone::object_destructor, obj.get()); - obj.release(); + m_finalizer_array.push(&zone::object_delete, obj.release()); } inline void zone::clear() @@ -284,9 +304,15 @@ inline void zone::swap(zone& o) } template -void zone::object_destructor(void* obj) +void zone::object_delete(void* obj) { - reinterpret_cast(obj)->~T(); + delete static_cast(obj); +} + +template +void zone::object_destruct(void* obj) +{ + static_cast(obj)->~T(); } inline void zone::undo_allocate(size_t size) @@ -301,7 +327,7 @@ T* zone::allocate(Args... args) { void* x = allocate_align(sizeof(T)); try { - m_finalizer_array.push(&zone::object_destructor, x); + m_finalizer_array.push(&zone::object_destruct, x); } catch (...) { undo_allocate(sizeof(T)); throw; diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 0c467384..a35e151b 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -961,7 +961,7 @@ private: std::size_t m_free; std::size_t m_off; std::size_t m_parsed; - zone* m_z; + msgpack::unique_ptr m_z; std::size_t m_initial_buffer_size; detail::context m_ctx; @@ -994,7 +994,7 @@ typedef enum { inline unpacker::unpacker(unpack_reference_func f, void* user_data, std::size_t initial_buffer_size) - :m_ctx(f, user_data) + :m_z(new zone), m_ctx(f, user_data) { if(initial_buffer_size < COUNTER_SIZE) { initial_buffer_size = COUNTER_SIZE; @@ -1005,19 +1005,12 @@ inline unpacker::unpacker(unpack_reference_func f, throw std::bad_alloc(); } - zone* z = zone::create(MSGPACK_ZONE_CHUNK_SIZE); - if(!z) { - ::free(buffer); - throw std::bad_alloc(); - } - m_buffer = buffer; m_used = COUNTER_SIZE; m_free = initial_buffer_size - m_used; m_off = COUNTER_SIZE; m_parsed = 0; m_initial_buffer_size = initial_buffer_size; - m_z = z; detail::init_count(m_buffer); @@ -1035,11 +1028,10 @@ inline unpacker::unpacker(unpacker&& other) m_free(other.m_free), m_off(other.m_off), m_parsed(other.m_parsed), - m_z(other.m_z), + m_z(std::move(other.m_z)), m_initial_buffer_size(other.m_initial_buffer_size), m_ctx(other.m_ctx) { other.m_buffer = nullptr; - other.m_z = nullptr; } inline unpacker& unpacker::operator=(unpacker&& other) { @@ -1054,7 +1046,6 @@ inline unpacker& unpacker::operator=(unpacker&& other) { inline unpacker::~unpacker() { // These checks are required for move operations. - if (m_z) zone::destroy(m_z); if (m_buffer) detail::decl_count(m_buffer); } @@ -1204,13 +1195,9 @@ inline zone* unpacker::release_zone() return nullptr; } - zone* r = zone::create(MSGPACK_ZONE_CHUNK_SIZE); - if(!r) { - return nullptr; - } - - zone* old = m_z; - m_z = r; + zone* r = new zone; + zone* old = m_z.release(); + m_z.reset(r); m_ctx.user().set_zone(*m_z); return old; @@ -1324,7 +1311,7 @@ inline void unpack(unpacked& result, unpack_reference_func f, void* user_data) { object obj; - msgpack::unique_ptr z(new zone()); + msgpack::unique_ptr z(new zone); bool referenced = false; unpack_return ret = detail::unpack_imp( data, len, off, *z, obj, referenced); diff --git a/src/zone.c b/src/zone.c index 9110e35d..33e25169 100644 --- a/src/zone.c +++ b/src/zone.c @@ -195,7 +195,7 @@ bool msgpack_zone_init(msgpack_zone* zone, size_t chunk_size) msgpack_zone* msgpack_zone_new(size_t chunk_size) { msgpack_zone* zone = (msgpack_zone*)malloc( - sizeof(msgpack_zone) + chunk_size); + sizeof(msgpack_zone)); if(zone == NULL) { return NULL; } From 0a99b9f933709f67414a21d3cdb58b167cff2eee Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 7 Aug 2014 23:26:09 +0900 Subject: [PATCH 106/153] Fixed the problem that reference function doesn't pass correctly. Fixed referenced flag writing timing on next(). It should place before flush. Added msgpack_tuple test for CMakeLists.txt Untabified CMakeLists.txt Added reference function test. --- include/msgpack/unpack.hpp | 4 +- test/CMakeLists.txt | 83 ++++--- test/Makefile.am | 7 +- test/msgpack_test.cpp | 40 ++++ test/reference.cc | 434 +++++++++++++++++++++++++++++++++++++ 5 files changed, 520 insertions(+), 48 deletions(-) create mode 100644 test/reference.cc diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index a35e151b..60df2f6d 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -1148,9 +1148,9 @@ inline bool unpacker::next(unpacked& result) return false; } else { + result.set_referenced(m_ctx.user().referenced()); result.zone().reset( release_zone() ); result.set(data()); - result.set_referenced(m_ctx.user().referenced()); reset(); return true; } @@ -1314,7 +1314,7 @@ inline void unpack(unpacked& result, msgpack::unique_ptr z(new zone); bool referenced = false; unpack_return ret = detail::unpack_imp( - data, len, off, *z, obj, referenced); + data, len, off, *z, obj, referenced, f, user_data); result.set_referenced(referenced); diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 252fd164..23536a3a 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -3,53 +3,50 @@ FIND_PACKAGE (ZLIB REQUIRED) FIND_PACKAGE (Threads REQUIRED) INCLUDE_DIRECTORIES ( - ${GTEST_INCLUDE_DIRS} - ${ZLIB_INCLUDE_DIRS} + ${GTEST_INCLUDE_DIRS} + ${ZLIB_INCLUDE_DIRS} ) SET (check_PROGRAMS - pack_unpack.cc - version.cc - streaming_c.cc - pack_unpack_c.cc - zone.cc - msgpack_test.cpp - buffer.cc - msgpackc_test.cpp - streaming.cc - convert.cc - fixint_c.cc + zone.cc + pack_unpack.cc + pack_unpack_c.cc + streaming.cc + streaming_c.cc + object.cc + version.cc + convert.cc + buffer.cc + cases.cc + fixint.cc + fixint_c.cc + msgpack_tuple.cc + msgpack_test.cpp + msgpackc_test.cpp + reference.cc ) -IF (MSGPACK_ENABLE_CXX) - LIST (APPEND check_PROGRAMS - cases.cc - fixint.cc - object.cc - ) -ENDIF () - FOREACH (source_file ${check_PROGRAMS}) - GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) - ADD_EXECUTABLE ( - ${source_file_we} - ${source_file} - ) - TARGET_LINK_LIBRARIES (${source_file_we} - msgpack - ${GTEST_BOTH_LIBRARIES} - ${ZLIB_LIBRARIES} - ${CMAKE_THREAD_LIBS_INIT} - ) - ADD_TEST (${source_file_we} ${source_file_we}) - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") - SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3") - ENDIF () - IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") - IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") - STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") - ELSE () - SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") - ENDIF () - ENDIF () + GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) + ADD_EXECUTABLE ( + ${source_file_we} + ${source_file} + ) + TARGET_LINK_LIBRARIES (${source_file_we} + msgpack + ${GTEST_BOTH_LIBRARIES} + ${ZLIB_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} + ) + ADD_TEST (${source_file_we} ${source_file_we}) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wall -g -O3") + ENDIF () + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + IF (CMAKE_CXX_FLAGS MATCHES "/W[0-4]") + STRING(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + ELSE () + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4") + ENDIF () + ENDIF () ENDFOREACH () diff --git a/test/Makefile.am b/test/Makefile.am index b7e9d00c..dfa7d3f0 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -1,4 +1,3 @@ - AM_CPPFLAGS = -I$(top_srcdir)/include AM_C_CPPFLAGS = -I$(top_srcdir)/include AM_LDFLAGS = $(top_builddir)/src/libmsgpack.la -lgtest_main -lgtest -pthread @@ -18,7 +17,8 @@ check_PROGRAMS = \ version \ msgpack_tuple \ msgpackc_test \ - msgpack_test + msgpack_test \ + reference TESTS = $(check_PROGRAMS) @@ -53,5 +53,6 @@ msgpackc_test_SOURCES = msgpackc_test.cpp msgpack_test_SOURCES = msgpack_test.cpp -EXTRA_DIST = cases.mpac cases_compact.mpac +reference_SOURCES = reference.cc +EXTRA_DIST = cases.mpac cases_compact.mpac diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 8dda3f39..53af6dfb 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,6 +38,7 @@ const double kEPS = 1e-10; msgpack::unpacked ret; \ msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ EXPECT_EQ(val1, ret.get().as()); \ + EXPECT_FALSE(ret.referenced()); \ } \ } while(0) @@ -205,6 +206,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) msgpack::unpack(ret, sbuf.data(), sbuf.size()); float_type val2 = ret.get().as(); EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + EXPECT_FALSE(ret.referenced()); } } @@ -242,6 +244,7 @@ TEST(MSGPACK, simple_buffer_double) msgpack::unpacked ret; msgpack::unpack(ret, sbuf.data(), sbuf.size()); double val2 = ret.get().as(); + EXPECT_FALSE(ret.referenced()); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -261,6 +264,7 @@ TEST(MSGPACK, simple_buffer_true) msgpack::unpack(ret, sbuf.data(), sbuf.size()); bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_false) @@ -272,6 +276,7 @@ TEST(MSGPACK, simple_buffer_false) msgpack::unpack(ret, sbuf.data(), sbuf.size()); bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext1) @@ -287,6 +292,7 @@ TEST(MSGPACK, simple_buffer_fixext1) EXPECT_EQ(1, ret.get().via.ext.size); EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_EQ(2, ret.get().via.ext.data()[0]); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext2) @@ -303,6 +309,7 @@ TEST(MSGPACK, simple_buffer_fixext2) EXPECT_EQ(0, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext4) @@ -319,6 +326,7 @@ TEST(MSGPACK, simple_buffer_fixext4) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext8) @@ -335,6 +343,7 @@ TEST(MSGPACK, simple_buffer_fixext8) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext16) @@ -351,6 +360,7 @@ TEST(MSGPACK, simple_buffer_fixext16) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_1byte_0) @@ -364,6 +374,7 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_0) msgpack::unpack(ret, sbuf.data(), sbuf.size()); EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_1byte_255) @@ -382,6 +393,7 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_2byte_256) @@ -400,6 +412,7 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_2byte_65535) @@ -418,6 +431,7 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_4byte_65536) @@ -436,6 +450,7 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); + EXPECT_FALSE(ret.referenced()); } //----------------------------------------------------------------------------- @@ -455,6 +470,7 @@ TEST(MSGPACK_STL, simple_buffer_string) string val2 = ret.get().as(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } } @@ -471,6 +487,7 @@ TEST(MSGPACK_STL, simple_buffer_vector) vector val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -487,6 +504,7 @@ TEST(MSGPACK_STL, simple_buffer_map) map val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -503,6 +521,7 @@ TEST(MSGPACK_STL, simple_buffer_deque) deque val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -519,6 +538,7 @@ TEST(MSGPACK_STL, simple_buffer_list) list val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -535,6 +555,7 @@ TEST(MSGPACK_STL, simple_buffer_set) set val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); } } @@ -549,6 +570,7 @@ TEST(MSGPACK_STL, simple_buffer_pair) pair val2 = ret.get().as >(); EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.second, val2.second); + EXPECT_FALSE(ret.referenced()); } } @@ -578,6 +600,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } @@ -604,6 +627,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } @@ -629,6 +653,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) EXPECT_TRUE(val2.find(it->first) != val2.end()); EXPECT_EQ(it->second, val2.find(it->first)->second); } + EXPECT_FALSE(ret.referenced()); } } @@ -658,6 +683,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -680,6 +706,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) tr1::unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) EXPECT_TRUE(val2.find(*it) != val2.end()); + EXPECT_FALSE(ret.referenced()); } } @@ -706,6 +733,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -730,6 +758,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map) EXPECT_TRUE(val2.find(it->first) != val2.end()); EXPECT_EQ(it->second, val2.find(it->first)->second); } + EXPECT_FALSE(ret.referenced()); } } @@ -759,6 +788,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -781,6 +811,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set) unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) EXPECT_TRUE(val2.find(*it) != val2.end()); + EXPECT_FALSE(ret.referenced()); } } @@ -807,6 +838,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); + EXPECT_FALSE(ret.referenced()); } } #endif @@ -823,6 +855,7 @@ TEST(MSGPACK_CPP11, simple_tuple) msgpack::unpack(ret, sbuf.data(), sbuf.size()); std::tuple val2 = ret.get().as >(); EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); } #endif // !defined(MSGPACK_USE_CPP03) @@ -849,6 +882,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) TestClass val2 = ret.get().as(); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); + EXPECT_FALSE(ret.referenced()); } } @@ -877,6 +911,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); + EXPECT_FALSE(ret.referenced()); } } @@ -927,6 +962,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); + EXPECT_FALSE(ret.referenced()); } #if !defined(MSGPACK_USE_CPP03) @@ -963,6 +999,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); + EXPECT_FALSE(ret.referenced()); } #endif // !defined(MSGPACK_USE_CPP03) @@ -1020,6 +1057,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) TestUnionMemberClass val2 = ret.get().as(); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); + EXPECT_FALSE(ret.referenced()); } { // int @@ -1032,6 +1070,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.value.i, 1); EXPECT_EQ(val1.value.i, val2.value.i); + EXPECT_FALSE(ret.referenced()); } } @@ -1054,6 +1093,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ test_type val2 = ret.get().as(); \ EXPECT_EQ(val1, val2); \ + EXPECT_FALSE(ret.referenced()); \ } \ } while(0); diff --git a/test/reference.cc b/test/reference.cc new file mode 100644 index 00000000..09ecbca5 --- /dev/null +++ b/test/reference.cc @@ -0,0 +1,434 @@ +#include +#include + +TEST(reference, unpack_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +bool never_called(msgpack::type::object_type, std::size_t, void*) +{ + EXPECT_TRUE(false); + return false; +} + +bool always_reference(msgpack::type::object_type, std::size_t, void*) +{ + return true; +} + +TEST(reference, unpack_int_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_string_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpack_bin_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpack_ext_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); + EXPECT_TRUE(ret.referenced()); +} + +static void* s_p; + +bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p) +{ + s_p = p; + switch (t) { + case msgpack::type::STR: + if (s >= 5) return true; + break; + case msgpack::type::BIN: + if (s >= 6) return true; + break; + case msgpack::type::EXT: + if (s >= 7) return true; + break; + default: + EXPECT_TRUE(false); + } + return false; +} + +TEST(reference, unpack_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpack_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + msgpack::unpacked ret; + s_p = nullptr; + // the last argument sbuf is any pointer as a user data. + // That is stored to s_p in sized_reference + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_FALSE(ret.referenced()); + // compare the passed argument with stored s_p. + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpack_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +// default reference function +// STR, BIN, and EXT are always referenced, otherwise copied (converted). + +TEST(reference, unpacker_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpacker_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("a")); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpacker_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpacker_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); +} + +// pass user custom reference function + +TEST(reference, unpacker_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacker unp(never_called, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpacker_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpacker_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} From dee68403df70630b66319f046cfa8fa7167fec9e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 8 Aug 2014 12:13:34 +0900 Subject: [PATCH 107/153] Replaced obsolete interface with recommended one on the example code. --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f9ce7de9..0f162c82 100644 --- a/README.md +++ b/README.md @@ -128,7 +128,7 @@ Install from package for this branch (poc/0.6) is not supported yet. // Deserialize the serialized data. msgpack::unpacked msg; // includes memory pool and deserialized object - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + msgpack::unpack(msg, sbuf.data(), sbuf.size()); msgpack::object obj = msg.get(); // Print the deserialized object to stdout. From 0201c21b9aba8b6c7e4dc1f00677d9470f855375 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 8 Aug 2014 14:28:03 +0900 Subject: [PATCH 108/153] Added minimum copy/reference threshold. Even if ref_size is given on vrefbuffer's constructor, the minimum size of vrefbuffer::ref_buffer is 10. Because int64, uint64, and double's msgpack expression size equals 9, and those buffer is allocated on the stack internally. --- include/msgpack/vrefbuffer.hpp | 8 +- src/vrefbuffer.c | 7 +- test/buffer.cc | 1 - test/msgpack_test.cpp | 175 +++++++++++++++++++++++++++++---- 4 files changed, 163 insertions(+), 28 deletions(-) diff --git a/include/msgpack/vrefbuffer.hpp b/include/msgpack/vrefbuffer.hpp index c8ac49af..4ce6cb45 100644 --- a/include/msgpack/vrefbuffer.hpp +++ b/include/msgpack/vrefbuffer.hpp @@ -40,8 +40,8 @@ struct iovec { namespace msgpack { namespace detail { - - + // int64, uint64, double + std::size_t const packer_max_buffer_size = 9; } // detail class vrefbuffer { @@ -57,7 +57,8 @@ private: public: vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) - :m_ref_size(ref_size), m_chunk_size(chunk_size) + :m_ref_size(std::max(ref_size, detail::packer_max_buffer_size + 1)), + m_chunk_size(chunk_size) { size_t nfirst = (sizeof(iovec) < 72/2) ? 72 / sizeof(iovec) : 8; @@ -277,4 +278,3 @@ private: } // namespace msgpack #endif /* msgpack/vrefbuffer.hpp */ - diff --git a/src/vrefbuffer.c b/src/vrefbuffer.c index ec5a0ead..1070ba2c 100644 --- a/src/vrefbuffer.c +++ b/src/vrefbuffer.c @@ -19,6 +19,8 @@ #include #include +#define MSGPACK_PACKER_MAX_BUFFER_SIZE 9 + struct msgpack_vrefbuffer_chunk { struct msgpack_vrefbuffer_chunk* next; /* data ... */ @@ -28,7 +30,9 @@ bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, size_t ref_size, size_t chunk_size) { vbuf->chunk_size = chunk_size; - vbuf->ref_size = ref_size; + vbuf->ref_size = + ref_size > MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ? + ref_size : MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ; size_t nfirst = (sizeof(struct iovec) < 72/2) ? 72 / sizeof(struct iovec) : 8; @@ -217,4 +221,3 @@ int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) return 0; } - diff --git a/test/buffer.cc b/test/buffer.cc index b72aeddf..512b0bc4 100644 --- a/test/buffer.cc +++ b/test/buffer.cc @@ -117,4 +117,3 @@ TEST(buffer, fbuffer_c) EXPECT_EQ(EOF, fgetc(file)); fclose(file); } - diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 53af6dfb..3201a82d 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -1076,13 +1076,12 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) //----------------------------------------------------------------------------- -#define GEN_TEST_VREF(test_type) \ +#define GEN_TEST_VREF(test_type, vbuf) \ do { \ vector v; \ v.push_back(0); \ for (unsigned int i = 0; i < v.size(); i++) { \ test_type val1 = v[i]; \ - msgpack::vrefbuffer vbuf; \ msgpack::pack(vbuf, val1); \ msgpack::sbuffer sbuf; \ const struct iovec* cur = vbuf.vector(); \ @@ -1099,97 +1098,231 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) TEST(MSGPACK, vrefbuffer_char) { - GEN_TEST_VREF(char); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(char, vbuf); } TEST(MSGPACK, vrefbuffer_signed_char) { - GEN_TEST_VREF(signed char); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(signed char, vbuf); } TEST(MSGPACK, vrefbuffer_unsigned_char) { - GEN_TEST_VREF(unsigned char); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned char, vbuf); } TEST(MSGPACK, vrefbuffer_short) { - GEN_TEST_VREF(short); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(short, vbuf); } TEST(MSGPACK, vrefbuffer_int) { - GEN_TEST_VREF(int); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int, vbuf); } TEST(MSGPACK, vrefbuffer_long) { - GEN_TEST_VREF(long); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long, vbuf); } TEST(MSGPACK, vrefbuffer_long_long) { - GEN_TEST_VREF(long long); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long long, vbuf); } TEST(MSGPACK, vrefbuffer_unsigned_short) { - GEN_TEST_VREF(unsigned short); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned short, vbuf); } TEST(MSGPACK, vrefbuffer_unsigned_int) { - GEN_TEST_VREF(unsigned int); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned int, vbuf); } TEST(MSGPACK, vrefbuffer_unsigned_long) { - GEN_TEST_VREF(unsigned long); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long, vbuf); } TEST(MSGPACK, vrefbuffer_unsigned_long_long) { - GEN_TEST_VREF(unsigned long long); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long long, vbuf); } TEST(MSGPACK, vrefbuffer_uint8) { - GEN_TEST_VREF(uint8_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint8_t, vbuf); } TEST(MSGPACK, vrefbuffer_uint16) { - GEN_TEST_VREF(uint16_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint16_t, vbuf); } TEST(MSGPACK, vrefbuffer_uint32) { - GEN_TEST_VREF(uint32_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint32_t, vbuf); } TEST(MSGPACK, vrefbuffer_uint64) { - GEN_TEST_VREF(uint64_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint64_t, vbuf); } TEST(MSGPACK, vrefbuffer_int8) { - GEN_TEST_VREF(int8_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int8_t, vbuf); } TEST(MSGPACK, vrefbuffer_int16) { - GEN_TEST_VREF(int16_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int16_t, vbuf); } TEST(MSGPACK, vrefbuffer_int32) { - GEN_TEST_VREF(int32_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int32_t, vbuf); } TEST(MSGPACK, vrefbuffer_int64) { - GEN_TEST_VREF(int64_t); + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int64_t, vbuf); +} + +// small ref_size and chunk_size +TEST(MSGPACK, vrefbuffer_small_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_signed_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(signed char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint64_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int64_t, vbuf); } //----------------------------------------------------------------------------- From b2f5893669a8897e8b45e83ff606e49029f13c4d Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 10 Aug 2014 22:04:31 +0900 Subject: [PATCH 109/153] Added reference to return value. --- include/msgpack/adaptor/map.hpp | 5 ++--- include/msgpack/adaptor/tr1/unordered_map.hpp | 5 ++--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index 5cbb6ede..464af7e4 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -94,7 +94,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector& v) template -inline std::map operator>> (object const& o, std::map& v) +inline std::map& operator>> (object const& o, std::map& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -150,7 +150,7 @@ inline void operator<< (object::with_zone& o, const std::map& v) template -inline std::multimap operator>> (object const& o, std::multimap& v) +inline std::multimap& operator>> (object const& o, std::multimap& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -202,4 +202,3 @@ inline void operator<< (object::with_zone& o, const std::multimap& v) } // namespace msgpack #endif /* msgpack/type/map.hpp */ - diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 7d8a18e8..b18af70f 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -44,7 +44,7 @@ namespace msgpack { template -inline MSGPACK_STD_TR1::unordered_map operator>> (object o, MSGPACK_STD_TR1::unordered_map& v) +inline MSGPACK_STD_TR1::unordered_map& operator>> (object o, MSGPACK_STD_TR1::unordered_map& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -93,7 +93,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m template -inline MSGPACK_STD_TR1::unordered_multimap operator>> (object o, MSGPACK_STD_TR1::unordered_multimap& v) +inline MSGPACK_STD_TR1::unordered_multimap& operator>> (object o, MSGPACK_STD_TR1::unordered_multimap& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -147,4 +147,3 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m #undef MSGPACK_STD_TR1 #endif /* msgpack/type/map.hpp */ - From 0bc4b3f5993e9361426c61c68043e603b6387915 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 10 Aug 2014 23:06:30 +0900 Subject: [PATCH 110/153] Added the C++11 std::array support. std::array is mapped to BIN. That is the same mannar as std::vector. --- CMakeLists.txt | 2 + include/msgpack/adaptor/cpp11/array.hpp | 68 +++++++++++++ include/msgpack/adaptor/cpp11/array_char.hpp | 74 ++++++++++++++ include/msgpack/type.hpp | 3 +- src/Makefile.am | 2 + test/CMakeLists.txt | 1 + test/Makefile.am | 3 + test/msgpack_test.cpp | 55 ---------- test/msgpack_test_cpp11.cpp | 102 +++++++++++++++++++ 9 files changed, 254 insertions(+), 56 deletions(-) create mode 100644 include/msgpack/adaptor/cpp11/array.hpp create mode 100644 include/msgpack/adaptor/cpp11/array_char.hpp create mode 100644 test/msgpack_test_cpp11.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 9c0caa51..d1418f04 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -79,6 +79,8 @@ IF (MSGPACK_ENABLE_CXX) LIST (APPEND msgpack_HEADERS include/msgpack.hpp include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/cpp11/array.hpp + include/msgpack/adaptor/cpp11/array_char.hpp include/msgpack/adaptor/cpp11/tuple.hpp include/msgpack/adaptor/define.hpp include/msgpack/adaptor/deque.hpp diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp new file mode 100644 index 00000000..1e2f6bbb --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -0,0 +1,68 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_ARRAY_HPP +#define MSGPACK_CPP11_ARRAY_HPP + +#include + +#include "msgpack/object.hpp" +#include "msgpack/cpp_config.hpp" + +namespace msgpack { + +template +inline std::array& operator>> (object const& o, std::array& v) { + if(o.type != type::ARRAY) { throw type_error(); } + if(o.via.array.size != N) { throw type_error(); } + if(o.via.array.size > 0) { + object* p = o.via.array.ptr; + object* const pend = o.via.array.ptr + o.via.array.size; + T* it = &v[0]; + do { + p->convert(*it); + ++p; + ++it; + } while(p < pend); + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::array& v) { + o.pack_array(v.size()); + for(auto const& e : v) o.pack(e); + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::array& v) { + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + for (auto const& e : v) *p++ = object(e, o.zone); + } +} + + +} // namespace msgpack + +#endif // MSGPACK_CPP11_ARRAY_HPP diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp new file mode 100644 index 00000000..e909f7e1 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array_char.hpp @@ -0,0 +1,74 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP +#define MSGPACK_TYPE_ARRAY_CHAR_HPP + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + +template +inline std::array& operator>> (object const& o, std::array& v) +{ + switch (o.type) { + case type::BIN: + if(o.via.bin.size != N) { throw type_error(); } + std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size); + break; + case type::STR: + if(o.via.str.size != N) { throw type_error(); } + std::memcpy(v.data(), o.via.str.ptr, N); + break; + default: + throw type_error(); + break; + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::array& v) +{ + o.pack_bin(v.size()); + o.pack_bin_body(v.data(), v.size()); + + return o; +} + +template +inline void operator<< (object& o, const std::array& v) +{ + o.type = type::BIN; + o.via.bin.ptr = v.data(); + o.via.bin.size = static_cast(v.size()); +} + +template +inline void operator<< (object::with_zone& o, const std::array& v) +{ + o.type = type::BIN; + char* ptr = static_cast(o.zone->allocate_align(v.size())); + o.via.bin.ptr = ptr; + o.via.bin.size = static_cast(v.size()); + std::memcpy(ptr, v.data(), v.size()); +} + +} // namespace msgpack + +#endif // MSGPACK_TYPE_ARRAY_CHAR_HPP diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp index 29ab7348..0a962667 100644 --- a/include/msgpack/type.hpp +++ b/include/msgpack/type.hpp @@ -20,7 +20,8 @@ #if !defined(MSGPACK_USE_CPP03) +#include "adaptor/cpp11/array.hpp" +#include "adaptor/cpp11/array_char.hpp" #include "adaptor/cpp11/tuple.hpp" #endif // !defined(MSGPACK_USE_CPP03) - diff --git a/src/Makefile.am b/src/Makefile.am index a729e102..2b03b944 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -53,6 +53,8 @@ if ENABLE_CXX nobase_include_HEADERS += \ ../include/msgpack.hpp \ ../include/msgpack/adaptor/bool.hpp \ + ../include/msgpack/adaptor/cpp11/array.hpp \ + ../include/msgpack/adaptor/cpp11/array_char.hpp \ ../include/msgpack/adaptor/cpp11/tuple.hpp \ ../include/msgpack/adaptor/define.hpp \ ../include/msgpack/adaptor/deque.hpp \ diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 23536a3a..a6b71df0 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -23,6 +23,7 @@ SET (check_PROGRAMS msgpack_tuple.cc msgpack_test.cpp msgpackc_test.cpp + msgpackc_test_cpp11.cpp reference.cc ) diff --git a/test/Makefile.am b/test/Makefile.am index dfa7d3f0..68858e76 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -18,6 +18,7 @@ check_PROGRAMS = \ msgpack_tuple \ msgpackc_test \ msgpack_test \ + msgpack_test_cpp11 \ reference TESTS = $(check_PROGRAMS) @@ -53,6 +54,8 @@ msgpackc_test_SOURCES = msgpackc_test.cpp msgpack_test_SOURCES = msgpack_test.cpp +msgpack_test_cpp11_SOURCES = msgpack_test_cpp11.cpp + reference_SOURCES = reference.cc EXTRA_DIST = cases.mpac cases_compact.mpac diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index 2340642a..f47aeeee 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -862,22 +862,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) } #endif -#if !defined(MSGPACK_USE_CPP03) -// C++11 - -TEST(MSGPACK_CPP11, simple_tuple) -{ - msgpack::sbuffer sbuf; - std::tuple val1(true, "kzk", 12.3); - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - std::tuple val2 = ret.get().as >(); - EXPECT_EQ(val1, val2); - EXPECT_FALSE(ret.referenced()); -} - -#endif // !defined(MSGPACK_USE_CPP03) // User-Defined Structures @@ -984,45 +968,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) EXPECT_FALSE(ret.referenced()); } -#if !defined(MSGPACK_USE_CPP03) - -class TestEnumClassMemberClass -{ -public: - TestEnumClassMemberClass() - : t1(TestEnumClassType::STATE_A), t2(TestEnumClassType::STATE_B), t3(TestEnumClassType::STATE_C) {} - - enum class TestEnumClassType:long { - STATE_INVALID = 0, - STATE_A = 1, - STATE_B = 2, - STATE_C = 3 - }; - TestEnumClassType t1; - TestEnumClassType t2; - TestEnumClassType t3; - - MSGPACK_DEFINE(t1, t2, t3); -}; - -MSGPACK_ADD_ENUM(TestEnumClassMemberClass::TestEnumClassType); - -TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) -{ - TestEnumClassMemberClass val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - TestEnumClassMemberClass val2 = ret.get().as(); - EXPECT_EQ(val1.t1, val2.t1); - EXPECT_EQ(val1.t2, val2.t2); - EXPECT_EQ(val1.t3, val2.t3); - EXPECT_FALSE(ret.referenced()); -} - -#endif // !defined(MSGPACK_USE_CPP03) - class TestUnionMemberClass { public: diff --git a/test/msgpack_test_cpp11.cpp b/test/msgpack_test_cpp11.cpp new file mode 100644 index 00000000..3ebf4611 --- /dev/null +++ b/test/msgpack_test_cpp11.cpp @@ -0,0 +1,102 @@ +#include "msgpack.hpp" + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +#if !defined(MSGPACK_USE_CPP03) + +// C++11 + +TEST(MSGPACK_CPP11, simple_tuple) +{ + msgpack::sbuffer sbuf; + std::tuple val1(true, "kzk", 12.3); + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + std::tuple val2 = ret.get().as >(); + EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); +} + +TEST(MSGPACK_CPP11, simple_array) +{ + for (unsigned int k = 0; k < kLoop; k++) { + array val1; + for (unsigned int i = 0; i < kElements; i++) + val1[i] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); + array val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + EXPECT_FALSE(ret.referenced()); + } +} + +TEST(MSGPACK_CPP11, simple_buffer_array_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + array val1; + for (unsigned int i = 0; i < kElements; i++) + val1[i] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::BIN); + array val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + + +class TestEnumClassMemberClass +{ +public: + TestEnumClassMemberClass() + : t1(TestEnumClassType::STATE_A), t2(TestEnumClassType::STATE_B), t3(TestEnumClassType::STATE_C) {} + + enum class TestEnumClassType:long { + STATE_INVALID = 0, + STATE_A = 1, + STATE_B = 2, + STATE_C = 3 + }; + TestEnumClassType t1; + TestEnumClassType t2; + TestEnumClassType t3; + + MSGPACK_DEFINE(t1, t2, t3); +}; + +MSGPACK_ADD_ENUM(TestEnumClassMemberClass::TestEnumClassType); + +TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) +{ + TestEnumClassMemberClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestEnumClassMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.t1, val2.t1); + EXPECT_EQ(val1.t2, val2.t2); + EXPECT_EQ(val1.t3, val2.t3); + EXPECT_FALSE(ret.referenced()); +} + +#endif // !defined(MSGPACK_USE_CPP03) From e217e72c22e08b8a73fa5513f7933fa261b47672 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 10 Aug 2014 23:23:52 +0900 Subject: [PATCH 111/153] Fixed msgpack::object type EXT comparison problem. Added msgpack::object type EXT ostream minimal output. --- include/msgpack/object.hpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index f0790279..7a69f33a 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -252,8 +252,8 @@ inline bool operator==(const object& x, const object& y) memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; case type::EXT: - return x.via.bin.size == y.via.bin.size && - memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + return x.via.ext.size == y.via.ext.size && + memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; case type::ARRAY: if(x.via.array.size != y.via.array.size) { @@ -517,6 +517,8 @@ inline std::ostream& operator<< (std::ostream& s, const object& o) (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"'; break; + case type::EXT: + s << "EXT"; case type::ARRAY: s << "["; @@ -558,4 +560,3 @@ inline std::ostream& operator<< (std::ostream& s, const object& o) #include "msgpack/type.hpp" #endif /* msgpack/object.hpp */ - From ea23bf843e3379d032fda8e330962a8cd1c4dc64 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 10 Aug 2014 23:45:50 +0900 Subject: [PATCH 112/153] Added std::forward_list support. Fixed cmake filename typo. --- CMakeLists.txt | 1 + .../msgpack/adaptor/cpp11/forward_list.hpp | 66 +++++++++++++++++++ include/msgpack/type.hpp | 1 + src/Makefile.am | 1 + test/CMakeLists.txt | 2 +- test/msgpack_test_cpp11.cpp | 16 +++++ 6 files changed, 86 insertions(+), 1 deletion(-) create mode 100644 include/msgpack/adaptor/cpp11/forward_list.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index d1418f04..87906e0f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -81,6 +81,7 @@ IF (MSGPACK_ENABLE_CXX) include/msgpack/adaptor/bool.hpp include/msgpack/adaptor/cpp11/array.hpp include/msgpack/adaptor/cpp11/array_char.hpp + include/msgpack/adaptor/cpp11/forward_list.hpp include/msgpack/adaptor/cpp11/tuple.hpp include/msgpack/adaptor/define.hpp include/msgpack/adaptor/deque.hpp diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp new file mode 100644 index 00000000..6f9fb575 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -0,0 +1,66 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_FORWARD_LIST_HPP +#define MSGPACK_CPP11_FORWARD_LIST_HPP + +#include + +#include "msgpack/object.hpp" +#include "msgpack/cpp_config.hpp" + +namespace msgpack { + +template +inline std::forward_list& operator>> (object const& o, std::forward_list& v) +{ + if(o.type != type::ARRAY) { throw type_error(); } + v.resize(o.via.array.size); + object* p = o.via.array.ptr; + for (auto &e : v) { + p->convert(e); + ++p; + } + return v; +} + +template +inline packer& operator<< (packer& o, const std::forward_list& v) +{ + o.pack_array(std::distance(v.begin(), v.end())); + for(auto const& e : v) o.pack(e); + return o; +} + +template +inline void operator<< (object::with_zone& o, const std::forward_list& v) +{ + o.type = type::ARRAY; + if(v.empty()) { + o.via.array.ptr = nullptr; + o.via.array.size = 0; + } else { + object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + for(auto const& e : v) *p++ = object(e, o.zone); + } +} + + +} // namespace msgpack + +#endif // MSGPACK_CPP11_FORWARD_LIST_HPP diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp index 0a962667..e1ef05a8 100644 --- a/include/msgpack/type.hpp +++ b/include/msgpack/type.hpp @@ -22,6 +22,7 @@ #include "adaptor/cpp11/array.hpp" #include "adaptor/cpp11/array_char.hpp" +#include "adaptor/cpp11/forward_list.hpp" #include "adaptor/cpp11/tuple.hpp" #endif // !defined(MSGPACK_USE_CPP03) diff --git a/src/Makefile.am b/src/Makefile.am index 2b03b944..37c5f776 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -55,6 +55,7 @@ nobase_include_HEADERS += \ ../include/msgpack/adaptor/bool.hpp \ ../include/msgpack/adaptor/cpp11/array.hpp \ ../include/msgpack/adaptor/cpp11/array_char.hpp \ + ../include/msgpack/adaptor/cpp11/forward_list.hpp \ ../include/msgpack/adaptor/cpp11/tuple.hpp \ ../include/msgpack/adaptor/define.hpp \ ../include/msgpack/adaptor/deque.hpp \ diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index a6b71df0..07db7f99 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -23,7 +23,7 @@ SET (check_PROGRAMS msgpack_tuple.cc msgpack_test.cpp msgpackc_test.cpp - msgpackc_test_cpp11.cpp + msgpack_test_cpp11.cpp reference.cc ) diff --git a/test/msgpack_test_cpp11.cpp b/test/msgpack_test_cpp11.cpp index 3ebf4611..0d13123b 100644 --- a/test/msgpack_test_cpp11.cpp +++ b/test/msgpack_test_cpp11.cpp @@ -63,6 +63,22 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char) } } +TEST(MSGPACK_STL, simple_buffer_forward_list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + forward_list val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_front(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + forward_list val2 = ret.get().as >(); + EXPECT_EQ(val1, val2); + EXPECT_FALSE(ret.referenced()); + } +} + class TestEnumClassMemberClass { From e18102d16ffa913be3265fc79b53a9a7bd6d71cb Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 11 Aug 2014 07:48:30 +0900 Subject: [PATCH 113/153] Replaced size() with std::distance. --- include/msgpack/adaptor/cpp11/forward_list.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index 6f9fb575..fe160d7d 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -55,7 +55,8 @@ inline void operator<< (object::with_zone& o, const std::forward_list& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast( + o.zone->allocate_align(sizeof(object)*std::distance(v.begin(), v.end()))); for(auto const& e : v) *p++ = object(e, o.zone); } } From 8920c49597ddc1e189b99ffe4cb178bc48305770 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 11 Aug 2014 09:01:17 +0900 Subject: [PATCH 114/153] Unified test files extension as cpp. --- test/CMakeLists.txt | 28 +-- test/Makefile.am | 28 +-- test/buffer.cpp | 119 +++++++++++ test/cases.cpp | 38 ++++ test/convert.cpp | 76 ++++++++ test/fixint.cpp | 55 ++++++ test/fixint_c.cpp | 32 +++ test/msgpack_tuple.cpp | 103 ++++++++++ test/object.cpp | 125 ++++++++++++ test/pack_unpack.cpp | 132 +++++++++++++ test/pack_unpack_c.cpp | 70 +++++++ test/reference.cpp | 434 +++++++++++++++++++++++++++++++++++++++++ test/streaming.cpp | 316 ++++++++++++++++++++++++++++++ test/streaming_c.cpp | 114 +++++++++++ test/version.cpp | 13 ++ test/zone.cpp | 78 ++++++++ 16 files changed, 1733 insertions(+), 28 deletions(-) create mode 100644 test/buffer.cpp create mode 100644 test/cases.cpp create mode 100644 test/convert.cpp create mode 100644 test/fixint.cpp create mode 100644 test/fixint_c.cpp create mode 100644 test/msgpack_tuple.cpp create mode 100644 test/object.cpp create mode 100644 test/pack_unpack.cpp create mode 100644 test/pack_unpack_c.cpp create mode 100644 test/reference.cpp create mode 100644 test/streaming.cpp create mode 100644 test/streaming_c.cpp create mode 100644 test/version.cpp create mode 100644 test/zone.cpp diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 07db7f99..4755f2d0 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -8,23 +8,23 @@ INCLUDE_DIRECTORIES ( ) SET (check_PROGRAMS - zone.cc - pack_unpack.cc - pack_unpack_c.cc - streaming.cc - streaming_c.cc - object.cc - version.cc - convert.cc - buffer.cc - cases.cc - fixint.cc - fixint_c.cc - msgpack_tuple.cc + zone.cpp + pack_unpack.cpp + pack_unpack_c.cpp + streaming.cpp + streaming_c.cpp + object.cpp + version.cpp + convert.cpp + buffer.cpp + cases.cpp + fixint.cpp + fixint_c.cpp + msgpack_tuple.cpp msgpack_test.cpp msgpackc_test.cpp msgpack_test_cpp11.cpp - reference.cc + reference.cpp ) FOREACH (source_file ${check_PROGRAMS}) diff --git a/test/Makefile.am b/test/Makefile.am index 68858e76..c336e3a6 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -23,32 +23,32 @@ check_PROGRAMS = \ TESTS = $(check_PROGRAMS) -zone_SOURCES = zone.cc +zone_SOURCES = zone.cpp -pack_unpack_SOURCES = pack_unpack.cc +pack_unpack_SOURCES = pack_unpack.cpp -pack_unpack_c_SOURCES = pack_unpack_c.cc +pack_unpack_c_SOURCES = pack_unpack_c.cpp -streaming_SOURCES = streaming.cc +streaming_SOURCES = streaming.cpp -streaming_c_SOURCES = streaming_c.cc +streaming_c_SOURCES = streaming_c.cpp -object_SOURCES = object.cc +object_SOURCES = object.cpp -convert_SOURCES = convert.cc +convert_SOURCES = convert.cpp -buffer_SOURCES = buffer.cc +buffer_SOURCES = buffer.cpp buffer_LDADD = -lz -cases_SOURCES = cases.cc +cases_SOURCES = cases.cpp -fixint_SOURCES = fixint.cc +fixint_SOURCES = fixint.cpp -fixint_c_SOURCES = fixint_c.cc +fixint_c_SOURCES = fixint_c.cpp -version_SOURCES = version.cc +version_SOURCES = version.cpp -msgpack_tuple_SOURCES = msgpack_tuple.cc +msgpack_tuple_SOURCES = msgpack_tuple.cpp msgpackc_test_SOURCES = msgpackc_test.cpp @@ -56,6 +56,6 @@ msgpack_test_SOURCES = msgpack_test.cpp msgpack_test_cpp11_SOURCES = msgpack_test_cpp11.cpp -reference_SOURCES = reference.cc +reference_SOURCES = reference.cpp EXTRA_DIST = cases.mpac cases_compact.mpac diff --git a/test/buffer.cpp b/test/buffer.cpp new file mode 100644 index 00000000..512b0bc4 --- /dev/null +++ b/test/buffer.cpp @@ -0,0 +1,119 @@ +#include +#include +#include +#include +#include +#include + +TEST(buffer, sbuffer) +{ + msgpack::sbuffer sbuf; + sbuf.write("a", 1); + sbuf.write("a", 1); + sbuf.write("a", 1); + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + + sbuf.clear(); + sbuf.write("a", 1); + sbuf.write("a", 1); + sbuf.write("a", 1); + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); +} + + +TEST(buffer, vrefbuffer) +{ + msgpack::vrefbuffer vbuf; + vbuf.write("a", 1); + vbuf.write("a", 1); + vbuf.write("a", 1); + + const struct iovec* vec = vbuf.vector(); + size_t veclen = vbuf.vector_size(); + + msgpack::sbuffer sbuf; + for(size_t i=0; i < veclen; ++i) { + sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); + } + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); + + + vbuf.clear(); + vbuf.write("a", 1); + vbuf.write("a", 1); + vbuf.write("a", 1); + + vec = vbuf.vector(); + veclen = vbuf.vector_size(); + + sbuf.clear(); + for(size_t i=0; i < veclen; ++i) { + sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); + } + + EXPECT_EQ(3, sbuf.size()); + EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); +} + + +TEST(buffer, zbuffer) +{ + msgpack::zbuffer zbuf; + zbuf.write("a", 1); + zbuf.write("a", 1); + zbuf.write("a", 1); + + zbuf.flush(); +} + + +TEST(buffer, fbuffer) +{ + FILE* file = tmpfile(); + EXPECT_TRUE( file != NULL ); + + msgpack::fbuffer fbuf(file); + EXPECT_EQ(file, fbuf.file()); + + fbuf.write("a", 1); + fbuf.write("a", 1); + fbuf.write("a", 1); + + fflush(file); + rewind(file); + for (size_t i=0; i < 3; ++i) { + int ch = fgetc(file); + EXPECT_TRUE(ch != EOF); + EXPECT_EQ('a', static_cast(ch)); + } + EXPECT_EQ(EOF, fgetc(file)); + fclose(file); +} + + +TEST(buffer, fbuffer_c) +{ + FILE* file = tmpfile(); + void* fbuf = (void*)file; + + EXPECT_TRUE( file != NULL ); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); + + fflush(file); + rewind(file); + for (size_t i=0; i < 3; ++i) { + int ch = fgetc(file); + EXPECT_TRUE(ch != EOF); + EXPECT_EQ('a', (char) ch); + } + EXPECT_EQ(EOF, fgetc(file)); + fclose(file); +} diff --git a/test/cases.cpp b/test/cases.cpp new file mode 100644 index 00000000..45aace0b --- /dev/null +++ b/test/cases.cpp @@ -0,0 +1,38 @@ +#include +#include +#include + +static void feed_file(msgpack::unpacker& pac, const char* path) +{ + std::ifstream fin(path); + while(true) { + pac.reserve_buffer(32*1024); + fin.read(pac.buffer(), pac.buffer_capacity()); + if(fin.bad()) { + throw std::runtime_error("read failed"); + } + pac.buffer_consumed(fin.gcount()); + if(fin.fail()) { + break; + } + } +} + +TEST(cases, format) +{ + msgpack::unpacker pac; + msgpack::unpacker pac_compact; + + feed_file(pac, "cases.mpac"); + feed_file(pac_compact, "cases_compact.mpac"); + + msgpack::unpacked result; + while(pac.next(&result)) { + msgpack::unpacked result_compact; + EXPECT_TRUE( pac_compact.next(&result_compact) ); + EXPECT_EQ(result_compact.get(), result.get()); + } + + EXPECT_FALSE( pac_compact.next(&result) ); +} + diff --git a/test/convert.cpp b/test/convert.cpp new file mode 100644 index 00000000..dcda77c6 --- /dev/null +++ b/test/convert.cpp @@ -0,0 +1,76 @@ +#include +#include + +class compatibility { +public: + compatibility() : str1("default"), str2("default") { } + + std::string str1; + std::string str2; + + MSGPACK_DEFINE(str1, str2); +}; + +TEST(convert, compatibility_less) +{ + std::vector src(1); + src[0] = "kumofs"; + + msgpack::zone z; + msgpack::object obj(src, &z); + + compatibility c; + EXPECT_NO_THROW( obj.convert(&c) ); + + EXPECT_EQ("kumofs", c.str1); + EXPECT_EQ("default", c.str2); +} + +TEST(convert, compatibility_more) +{ + std::vector src(3); + src[0] = "kumofs"; + src[1] = "mpio"; + src[2] = "cloudy"; + + msgpack::zone z; + msgpack::object obj(src, &z); + + compatibility to; + EXPECT_NO_THROW( obj.convert(&to) ); + + EXPECT_EQ("kumofs", to.str1); + EXPECT_EQ("mpio", to.str2); +} + + +class enum_member { +public: + enum_member() : flag(A) { } + + enum flags_t { + A = 0, + B = 1 + }; + + flags_t flag; + + MSGPACK_DEFINE(flag); +}; + +MSGPACK_ADD_ENUM(enum_member::flags_t); + +TEST(convert, enum_member) +{ + enum_member src; + src.flag = enum_member::B; + + msgpack::zone z; + msgpack::object obj(src, &z); + + enum_member to; + EXPECT_NO_THROW( obj.convert(&to) ); + + EXPECT_EQ(enum_member::B, to.flag); +} + diff --git a/test/fixint.cpp b/test/fixint.cpp new file mode 100644 index 00000000..cf109ae5 --- /dev/null +++ b/test/fixint.cpp @@ -0,0 +1,55 @@ +#include +#include + +template +void check_size(size_t size) { + T v(0); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, v); + EXPECT_EQ(size, sbuf.size()); +} + +TEST(fixint, size) +{ + check_size(2); + check_size(3); + check_size(5); + check_size(9); + + check_size(2); + check_size(3); + check_size(5); + check_size(9); +} + + +template +void check_convert() { + T v1(-11); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, v1); + + msgpack::unpacked msg; + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + + T v2; + msg.get().convert(&v2); + + EXPECT_EQ(v1.get(), v2.get()); + + EXPECT_EQ(msg.get(), msgpack::object(T(v1.get()))); +} + +TEST(fixint, convert) +{ + check_convert(); + check_convert(); + check_convert(); + check_convert(); + + check_convert(); + check_convert(); + check_convert(); + check_convert(); +} + diff --git a/test/fixint_c.cpp b/test/fixint_c.cpp new file mode 100644 index 00000000..d9dc5180 --- /dev/null +++ b/test/fixint_c.cpp @@ -0,0 +1,32 @@ +#include +#include + +TEST(fixint, size) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + size_t sum = 0; + + EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0)); + EXPECT_EQ(sum+=2, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0)); + EXPECT_EQ(sum+=3, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0)); + EXPECT_EQ(sum+=5, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0)); + EXPECT_EQ(sum+=9, sbuf->size); + + EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0)); + EXPECT_EQ(sum+=2, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0)); + EXPECT_EQ(sum+=3, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0)); + EXPECT_EQ(sum+=5, sbuf->size); + EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0)); + EXPECT_EQ(sum+=9, sbuf->size); + + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); +} + diff --git a/test/msgpack_tuple.cpp b/test/msgpack_tuple.cpp new file mode 100644 index 00000000..9779d06a --- /dev/null +++ b/test/msgpack_tuple.cpp @@ -0,0 +1,103 @@ +#include +#include + + +TEST(msgpack_tuple, member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} + +TEST(msgpack_tuple, non_member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, msgpack::type::get<0>(t1)); + EXPECT_EQ(true, msgpack::type::get<1>(t1)); + EXPECT_EQ("ABC", msgpack::type::get<2>(t1)); + msgpack::type::get<0>(t1) = 40; + msgpack::type::get<1>(t1) = false; + msgpack::type::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, msgpack::type::get<0>(t1)); + EXPECT_EQ(false, msgpack::type::get<1>(t1)); + EXPECT_EQ("DEFG", msgpack::type::get<2>(t1)); +} + +#if __cplusplus >= 201103 +TEST(msgpack_tuple, std_non_member_get) +{ + msgpack::type::tuple t1(42, true, "ABC"); + EXPECT_EQ(42, std::get<0>(t1)); + EXPECT_EQ(true, std::get<1>(t1)); + EXPECT_EQ("ABC", std::get<2>(t1)); + std::get<0>(t1) = 40; + std::get<1>(t1) = false; + std::get<2>(t1) = "DEFG"; + EXPECT_EQ(40, std::get<0>(t1)); + EXPECT_EQ(false, std::get<1>(t1)); + EXPECT_EQ("DEFG", std::get<2>(t1)); +} + +TEST(msgpack_tuple, make_tuple) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); + t1.get<0>() = 40; + t1.get<1>() = false; + t1.get<2>() = "DEFG"; + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} + +TEST(msgpack_tuple, std_make_tuple) +{ + msgpack::type::tuple t1 = std::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, t1.get<0>()); + EXPECT_EQ(true, t1.get<1>()); + EXPECT_EQ("ABC", t1.get<2>()); +} + +TEST(msgpack_tuple, tie) +{ + int i(43); + bool b(false); + std::string s("DEFG"); + msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC"); + EXPECT_EQ(42, i); + EXPECT_EQ(true, b); + EXPECT_EQ("ABC", s); +} + +TEST(msgpack_tuple, tuple_cat) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42); + msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); + msgpack::type::tuple t3 = msgpack::type::tuple_cat(t1, std::move(t2)); + EXPECT_EQ(42, t3.get<0>()); + EXPECT_EQ(true, t3.get<1>()); + EXPECT_EQ("ABC", t3.get<2>()); +} + +TEST(msgpack_tuple, swap) +{ + msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); + msgpack::type::tuple t2 = msgpack::type::make_tuple(40, false, "DEFG"); + msgpack::type::swap(t1, t2); + EXPECT_EQ(42, t2.get<0>()); + EXPECT_EQ(true, t2.get<1>()); + EXPECT_EQ("ABC", t2.get<2>()); + EXPECT_EQ(40, t1.get<0>()); + EXPECT_EQ(false, t1.get<1>()); + EXPECT_EQ("DEFG", t1.get<2>()); +} +#endif diff --git a/test/object.cpp b/test/object.cpp new file mode 100644 index 00000000..88490fb5 --- /dev/null +++ b/test/object.cpp @@ -0,0 +1,125 @@ +#include +#include + +struct myclass { + myclass() : num(0), str("default") { } + + myclass(int num, const std::string& str) : + num(0), str("default") { } + + ~myclass() { } + + int num; + std::string str; + + MSGPACK_DEFINE(num, str); + + bool operator==(const myclass& o) const + { + return num == o.num && str == o.str; + } +}; + +std::ostream& operator<<(std::ostream& o, const myclass& m) +{ + return o << "myclass("<()); +} + + +TEST(object, print) +{ + msgpack::object obj; + std::cout << obj << std::endl; +} + + +TEST(object, is_nil) +{ + msgpack::object obj; + EXPECT_TRUE(obj.is_nil()); +} + + +TEST(object, type_error) +{ + msgpack::object obj(1); + EXPECT_THROW(obj.as(), msgpack::type_error); + EXPECT_THROW(obj.as >(), msgpack::type_error); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1, obj.as()); + EXPECT_EQ(1u, obj.as()); + EXPECT_EQ(1u, obj.as()); +} + + +TEST(object, equal_primitive) +{ + msgpack::object obj_nil; + EXPECT_EQ(obj_nil, msgpack::object()); + + msgpack::object obj_int(1); + EXPECT_EQ(obj_int, msgpack::object(1)); + EXPECT_EQ(obj_int, 1); + + msgpack::object obj_double(1.2); + EXPECT_EQ(obj_double, msgpack::object(1.2)); + EXPECT_EQ(obj_double, 1.2); + + msgpack::object obj_bool(true); + EXPECT_EQ(obj_bool, msgpack::object(true)); + EXPECT_EQ(obj_bool, true); +} + + +TEST(object, construct_primitive) +{ + msgpack::object obj_nil; + EXPECT_EQ(msgpack::type::NIL, obj_nil.type); + + msgpack::object obj_uint(1); + EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type); + EXPECT_EQ(1u, obj_uint.via.u64); + + msgpack::object obj_int(-1); + EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type); + EXPECT_EQ(-1, obj_int.via.i64); + + msgpack::object obj_double(1.2); + EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type); + EXPECT_EQ(1.2, obj_double.via.dec); + + msgpack::object obj_bool(true); + EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type); + EXPECT_EQ(true, obj_bool.via.boolean); +} diff --git a/test/pack_unpack.cpp b/test/pack_unpack.cpp new file mode 100644 index 00000000..b95bccde --- /dev/null +++ b/test/pack_unpack.cpp @@ -0,0 +1,132 @@ +#include +#include +#include + +TEST(pack, num) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); +} + + +TEST(pack, vector) +{ + msgpack::sbuffer sbuf; + std::vector vec; + vec.push_back(1); + vec.push_back(2); + vec.push_back(3); + msgpack::pack(sbuf, vec); +} + + +TEST(pack, to_ostream) +{ + std::ostringstream stream; + msgpack::pack(stream, 1); +} + + +struct myclass { + myclass() : num(0), str("default") { } + + myclass(int num, const std::string& str) : + num(num), str(str) { } + + ~myclass() { } + + int num; + std::string str; + + MSGPACK_DEFINE(num, str); +}; + + +TEST(pack, myclass) +{ + msgpack::sbuffer sbuf; + myclass m(1, "msgpack"); + msgpack::pack(sbuf, m); +} + +TEST(unpack, int_no_offset) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + msgpack::unpack(msg, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, int_offset) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + std::size_t off = 0; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + std::size_t off = 0; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_null_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, int_default_null_pointer) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, sequence) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::pack(sbuf, 2); + msgpack::pack(sbuf, 3); + + std::size_t off = 0; + + msgpack::unpacked msg; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(1, msg.get().as()); + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(2, msg.get().as()); + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); + EXPECT_EQ(3, msg.get().as()); + + EXPECT_EQ(off, sbuf.size()); +} diff --git a/test/pack_unpack_c.cpp b/test/pack_unpack_c.cpp new file mode 100644 index 00000000..60e0e00e --- /dev/null +++ b/test/pack_unpack_c.cpp @@ -0,0 +1,70 @@ +#include +#include +#include + +TEST(pack, num) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); +} + + +TEST(pack, array) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + EXPECT_EQ(0, msgpack_pack_array(pk, 3)); + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + + msgpack_sbuffer_free(sbuf); + msgpack_packer_free(pk); +} + + +TEST(unpack, sequence) +{ + msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); + msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); + + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + + msgpack_packer_free(pk); + + bool success; + size_t offset = 0; + + msgpack_unpacked msg; + msgpack_unpacked_init(&msg); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(1, msg.data.via.u64); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(2, msg.data.via.u64); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_TRUE(success); + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); + EXPECT_EQ(3, msg.data.via.u64); + + success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); + EXPECT_FALSE(success); + + msgpack_sbuffer_free(sbuf); + msgpack_unpacked_destroy(&msg); +} + diff --git a/test/reference.cpp b/test/reference.cpp new file mode 100644 index 00000000..09ecbca5 --- /dev/null +++ b/test/reference.cpp @@ -0,0 +1,434 @@ +#include +#include + +TEST(reference, unpack_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_FALSE(ret.referenced()); +} + +bool never_called(msgpack::type::object_type, std::size_t, void*) +{ + EXPECT_TRUE(false); + return false; +} + +bool always_reference(msgpack::type::object_type, std::size_t, void*) +{ + return true; +} + +TEST(reference, unpack_int_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpack_string_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + msgpack::unpacked ret; + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpack_bin_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpack_ext_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); + EXPECT_TRUE(ret.referenced()); +} + +static void* s_p; + +bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p) +{ + s_p = p; + switch (t) { + case msgpack::type::STR: + if (s >= 5) return true; + break; + case msgpack::type::BIN: + if (s >= 6) return true; + break; + case msgpack::type::EXT: + if (s >= 7) return true; + break; + default: + EXPECT_TRUE(false); + } + return false; +} + +TEST(reference, unpack_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpack_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + msgpack::unpacked ret; + s_p = nullptr; + // the last argument sbuf is any pointer as a user data. + // That is stored to s_p in sized_reference + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_FALSE(ret.referenced()); + // compare the passed argument with stored s_p. + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpack_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + s_p = nullptr; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +// default reference function +// STR, BIN, and EXT are always referenced, otherwise copied (converted). + +TEST(reference, unpacker_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); +} + +TEST(reference, unpacker_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("a")); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpacker_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); +} + +TEST(reference, unpacker_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp; + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); +} + +// pass user custom reference function + +TEST(reference, unpacker_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacker unp(never_called, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpacker_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpacker_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_FALSE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpacker_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacker unp(sized_reference, &sbuf); + msgpack::unpacked ret; + unp.reserve_buffer(sbuf.size()); + std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); + unp.buffer_consumed(sbuf.size()); + s_p = nullptr; + bool b = unp.next(ret); + EXPECT_TRUE(b); + EXPECT_TRUE(ret.referenced()); + EXPECT_EQ(&sbuf, s_p); +} diff --git a/test/streaming.cpp b/test/streaming.cpp new file mode 100644 index 00000000..2daa98a1 --- /dev/null +++ b/test/streaming.cpp @@ -0,0 +1,316 @@ +#include +#include +#include + +TEST(streaming, basic) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); + + // read buffer into pac.buffer() upto + // pac.buffer_capacity() bytes. + size_t len = 1; + memcpy(pac.buffer(), input, len); + input += len; + + pac.buffer_consumed(len); + + while(pac.next(result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + } +} + +TEST(streaming, basic_pointer) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); + + // read buffer into pac.buffer() upto + // pac.buffer_capacity() bytes. + size_t len = 1; + memcpy(pac.buffer(), input, len); + input += len; + + pac.buffer_consumed(len); + + while(pac.next(&result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + } +} + +#if !defined(MSGPACK_USE_CPP03) + +TEST(streaming, move) +{ + msgpack::sbuffer buffer; + + msgpack::packer pk(&buffer); + pk.pack(1); + pk.pack(2); + pk.pack(3); + + const char* input = buffer.data(); + const char* const eof = input + buffer.size(); + + msgpack::unpacker pac; + msgpack::unpacked result; + + int count = 0; + while(count < 3) { + msgpack::unpacker pac_in(std::move(pac)); + pac_in.reserve_buffer(32*1024); + + // read buffer into pac_in.buffer() upto + // pac_in.buffer_capac_inity() bytes. + size_t len = 1; + memcpy(pac_in.buffer(), input, len); + input += len; + + pac_in.buffer_consumed(len); + + while(pac_in.next(result)) { + msgpack::object obj = result.get(); + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + } + + EXPECT_TRUE(input < eof); + pac = std::move(pac_in); + } +} + +#endif // !defined(MSGPACK_USE_CPP03) + +class event_handler { +public: + event_handler(std::istream& input) : input(input) { } + ~event_handler() { } + + void on_read() + { + while(true) { + pac.reserve_buffer(32*1024); + + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + + if(len == 0) { + return; + } + + pac.buffer_consumed(len); + + msgpack::unpacked result; + while(pac.next(result)) { + on_message(result.get(), msgpack::move(result.zone())); + } + + if(pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } + } + + void on_message(msgpack::object obj, msgpack::unique_ptr z) + { + EXPECT_EQ(expect, obj.as()); + } + + int expect; + +private: + std::istream& input; + msgpack::unpacker pac; +}; + +TEST(streaming, event) +{ + std::stringstream stream; + msgpack::packer pk(&stream); + + event_handler handler(stream); + + pk.pack(1); + handler.expect = 1; + handler.on_read(); + + pk.pack(2); + handler.expect = 2; + handler.on_read(); + + pk.pack(3); + handler.expect = 3; + handler.on_read(); +} + + +// backward compatibility +TEST(streaming, basic_compat) +{ + std::ostringstream stream; + msgpack::packer pk(&stream); + + pk.pack(1); + pk.pack(2); + pk.pack(3); + + std::istringstream input(stream.str()); + + msgpack::unpacker pac; + + int count = 0; + while(count < 3) { + pac.reserve_buffer(32*1024); + + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + pac.buffer_consumed(len); + + while(pac.execute()) { + msgpack::unique_ptr z(pac.release_zone()); + msgpack::object obj = pac.data(); + pac.reset(); + + switch(count++) { + case 0: + EXPECT_EQ(1, obj.as()); + break; + case 1: + EXPECT_EQ(2, obj.as()); + break; + case 2: + EXPECT_EQ(3, obj.as()); + return; + } + + } + } +} + + +// backward compatibility +class event_handler_compat { +public: + event_handler_compat(std::istream& input) : input(input) { } + ~event_handler_compat() { } + + void on_read() + { + while(true) { + pac.reserve_buffer(32*1024); + + size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); + + if(len == 0) { + return; + } + + pac.buffer_consumed(len); + + while(pac.execute()) { + msgpack::unique_ptr z(pac.release_zone()); + msgpack::object obj = pac.data(); + pac.reset(); + on_message(obj, msgpack::move(z)); + } + + if(pac.message_size() > 10*1024*1024) { + throw std::runtime_error("message is too large"); + } + } + } + + void on_message(msgpack::object obj, msgpack::unique_ptr z) + { + EXPECT_EQ(expect, obj.as()); + } + + int expect; + +private: + std::istream& input; + msgpack::unpacker pac; +}; + +TEST(streaming, event_compat) +{ + std::stringstream stream; + msgpack::packer pk(&stream); + + event_handler_compat handler(stream); + + pk.pack(1); + handler.expect = 1; + handler.on_read(); + + pk.pack(2); + handler.expect = 2; + handler.on_read(); + + pk.pack(3); + handler.expect = 3; + handler.on_read(); +} diff --git a/test/streaming_c.cpp b/test/streaming_c.cpp new file mode 100644 index 00000000..159eef76 --- /dev/null +++ b/test/streaming_c.cpp @@ -0,0 +1,114 @@ +#include +#include +#include + +TEST(streaming, basic) +{ + msgpack_sbuffer* buffer = msgpack_sbuffer_new(); + + msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); + + // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} + EXPECT_EQ(0, msgpack_pack_int(pk, 1)); + EXPECT_EQ(0, msgpack_pack_int(pk, 2)); + EXPECT_EQ(0, msgpack_pack_int(pk, 3)); + EXPECT_EQ(0, msgpack_pack_str(pk, 3)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 1)); + EXPECT_EQ(0, msgpack_pack_str(pk, 8)); + EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); + EXPECT_EQ(0, msgpack_pack_array(pk, 1)); + EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); + EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); + EXPECT_EQ(0, msgpack_pack_map(pk, 1)); + EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); + EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); + int max_count = 6; + + msgpack_packer_free(pk); + + const char* input = buffer->data; + const char* const eof = input + buffer->size; + + msgpack_unpacker pac; + msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); + + msgpack_unpacked result; + msgpack_unpacked_init(&result); + + int count = 0; + while(count < max_count) { + bool unpacked = false; + + msgpack_unpacker_reserve_buffer(&pac, 32*1024); + + while(!unpacked) { + /* read buffer into msgpack_unapcker_buffer(&pac) upto + * msgpack_unpacker_buffer_capacity(&pac) bytes. */ + memcpy(msgpack_unpacker_buffer(&pac), input, 1); + input += 1; + + EXPECT_TRUE(input <= eof); + + msgpack_unpacker_buffer_consumed(&pac, 1); + + while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) { + unpacked = 1; + msgpack_object obj = result.data; + msgpack_object e; + switch(count++) { + case 0: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(1, obj.via.u64); + break; + case 1: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(2, obj.via.u64); + break; + case 2: + EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); + EXPECT_EQ(3, obj.via.u64); + break; + case 3: + EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); + EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); + break; + case 4: + EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); + EXPECT_EQ(1, obj.via.array.size); + e = obj.via.array.ptr[0]; + EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); + EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); + break; + case 5: + EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); + EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); + break; + case 6: + EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); + EXPECT_EQ(1, obj.via.array.size); + e = obj.via.array.ptr[0]; + EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); + EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); + break; + case 7: + EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); + EXPECT_EQ(1, obj.via.map.size); + e = obj.via.map.ptr[0].key; + EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); + ASSERT_FLOAT_EQ(0.4, (float)e.via.dec); + e = obj.via.map.ptr[0].val; + EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); + ASSERT_DOUBLE_EQ(0.8, e.via.dec); + break; + } + } + } + } + + msgpack_unpacker_destroy(&pac); + msgpack_unpacked_destroy(&result); +} + diff --git a/test/version.cpp b/test/version.cpp new file mode 100644 index 00000000..d2809b21 --- /dev/null +++ b/test/version.cpp @@ -0,0 +1,13 @@ +#include +#include + +TEST(version, print) +{ + printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); + printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); + printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); + printf("msgpack_version() : %s\n", msgpack_version()); + printf("msgpack_version_major() : %d\n", msgpack_version_major()); + printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); +} + diff --git a/test/zone.cpp b/test/zone.cpp new file mode 100644 index 00000000..b2dc543e --- /dev/null +++ b/test/zone.cpp @@ -0,0 +1,78 @@ +#include +#include + +TEST(zone, allocate_align) +{ + msgpack::zone z; + char* buf1 = (char*)z.allocate_align(4); + memcpy(buf1, "test", 4); + char* buf2 = (char*)z.allocate_align(4); + memcpy(buf2, "test", 4); +} + + +class myclass { +public: + myclass() : num(0), str("default") { } + + myclass(int num, const std::string& str) : + num(num), str(str) { } + + ~myclass() { } + + int num; + std::string str; + +private: + myclass(const myclass&); +}; + + +TEST(zone, allocate) +{ + msgpack::zone z; + myclass* m = z.allocate(); + EXPECT_EQ(m->num, 0); + EXPECT_EQ(m->str, "default"); +} + + +TEST(zone, allocate_constructor) +{ + msgpack::zone z; + myclass* m = z.allocate(7, "msgpack"); + EXPECT_EQ(m->num, 7); + EXPECT_EQ(m->str, "msgpack"); +} + + +static void custom_finalizer_func(void* user) +{ + myclass* m = (myclass*)user; + delete m; +} + +TEST(zone, push_finalizer) +{ + msgpack::zone z; + myclass* m = new myclass(); + z.push_finalizer(custom_finalizer_func, (void*)m); +} + + +TEST(zone, push_finalizer_unique_ptr) +{ + msgpack::zone z; + msgpack::unique_ptr am(new myclass()); + z.push_finalizer(msgpack::move(am)); +} + + +TEST(zone, allocate_no_align) +{ + msgpack::zone z; + char* buf1 = (char*)z.allocate_no_align(4); + char* buf2 = (char*)z.allocate_no_align(4); + EXPECT_EQ(buf1+4, buf2); +} + From f969f6f39ced8117ce35bba4cdaf9ab7f000a0d1 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 11 Aug 2014 13:23:27 +0900 Subject: [PATCH 115/153] Replaced zone* member variable in object with zone&. Added msgpack::object::with_zone tests. Added tuples operator<<'s parameter to const. Fixed array object::with_zone pointer and size unset problem. Fixed forward_list object::with_zone pointer and size unset problem. --- erb/cpp03_define.hpp.erb | 8 +- erb/cpp03_msgpack_tuple.hpp.erb | 2 +- include/msgpack/adaptor/cpp11/array.hpp | 4 +- include/msgpack/adaptor/cpp11/array_char.hpp | 2 +- .../msgpack/adaptor/cpp11/forward_list.hpp | 5 +- include/msgpack/adaptor/cpp11/tuple.hpp | 4 +- include/msgpack/adaptor/deque.hpp | 2 +- .../msgpack/adaptor/detail/cpp03_define.hpp | 132 ++-- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 64 +- .../msgpack/adaptor/detail/cpp11_define.hpp | 12 +- .../adaptor/detail/cpp11_msgpack_tuple.hpp | 4 +- include/msgpack/adaptor/list.hpp | 2 +- include/msgpack/adaptor/map.hpp | 6 +- include/msgpack/adaptor/pair.hpp | 2 +- include/msgpack/adaptor/set.hpp | 4 +- include/msgpack/adaptor/string.hpp | 2 +- include/msgpack/adaptor/tr1/unordered_map.hpp | 4 +- include/msgpack/adaptor/tr1/unordered_set.hpp | 4 +- include/msgpack/adaptor/vector.hpp | 2 +- include/msgpack/adaptor/vector_char.hpp | 2 +- include/msgpack/object.hpp | 19 +- test/CMakeLists.txt | 1 + test/Makefile.am | 3 + test/buffer.cc | 119 ---- test/cases.cc | 38 - test/convert.cc | 76 -- test/fixint.cc | 55 -- test/fixint_c.cc | 32 - test/msgpack_tuple.cc | 103 --- test/object.cc | 125 ---- test/object_with_zone.cpp | 662 ++++++++++++++++++ test/pack_unpack.cc | 132 ---- test/pack_unpack_c.cc | 70 -- test/reference.cc | 434 ------------ test/streaming.cc | 316 --------- test/streaming_c.cc | 114 --- test/version.cc | 13 - test/zone.cc | 78 --- 38 files changed, 818 insertions(+), 1839 deletions(-) delete mode 100644 test/buffer.cc delete mode 100644 test/cases.cc delete mode 100644 test/convert.cc delete mode 100644 test/fixint.cc delete mode 100644 test/fixint_c.cc delete mode 100644 test/msgpack_tuple.cc delete mode 100644 test/object.cc create mode 100644 test/object_with_zone.cpp delete mode 100644 test/pack_unpack.cc delete mode 100644 test/pack_unpack_c.cc delete mode 100644 test/reference.cc delete mode 100644 test/streaming.cc delete mode 100644 test/streaming_c.cc delete mode 100644 test/version.cc delete mode 100644 test/zone.cc diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index fa27ecd6..10ef4502 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -29,7 +29,7 @@ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ } @@ -82,7 +82,7 @@ struct define<> { { if(o.type != type::ARRAY) { throw type_error(); } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; o->via.array.ptr = nullptr; @@ -115,10 +115,10 @@ struct define, A<%=j%><%}%>> { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*<%=i+1%>)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*<%=i+1%>)); o->via.array.size = <%=i+1%>; <%0.upto(i) {|j|%> o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%> diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index c0c73c61..5fa95fcc 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -184,7 +184,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple, A<%=j%><%}%>>& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*<%=i+1%>)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*<%=i+1%>)); o.via.array.size = <%=i+1%>; <%0.upto(i) {|j|%> o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%> diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp index 1e2f6bbb..be89559b 100644 --- a/include/msgpack/adaptor/cpp11/array.hpp +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -57,7 +57,9 @@ inline void operator<< (object::with_zone& o, const std::array& v) { o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); + o.via.array.size = v.size(); + o.via.array.ptr = p; for (auto const& e : v) *p++ = object(e, o.zone); } } diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp index e909f7e1..71f1e87d 100644 --- a/include/msgpack/adaptor/cpp11/array_char.hpp +++ b/include/msgpack/adaptor/cpp11/array_char.hpp @@ -63,7 +63,7 @@ template inline void operator<< (object::with_zone& o, const std::array& v) { o.type = type::BIN; - char* ptr = static_cast(o.zone->allocate_align(v.size())); + char* ptr = static_cast(o.zone.allocate_align(v.size())); o.via.bin.ptr = ptr; o.via.bin.size = static_cast(v.size()); std::memcpy(ptr, v.data(), v.size()); diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index fe160d7d..272a7ef3 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -55,8 +55,11 @@ inline void operator<< (object::with_zone& o, const std::forward_list& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { + std::size_t size = std::distance(v.begin(), v.end()); + o.via.array.size = size; object* p = static_cast( - o.zone->allocate_align(sizeof(object)*std::distance(v.begin(), v.end()))); + o.zone.allocate_align(sizeof(object)*size)); + o.via.array.ptr = p; for(auto const& e : v) *p++ = object(e, o.zone); } } diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index 6c9d0694..79298d6e 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -108,9 +108,9 @@ struct StdTupleToObjectWithZone { template inline void operator<< ( object::with_zone& o, - std::tuple& v) { + std::tuple const& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*sizeof...(Args))); o.via.array.size = sizeof...(Args); StdTupleToObjectWithZone::convert(o, v); } diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index 089c04f2..c6571343 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::deque& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index 7089c7f7..30090d3e 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -29,7 +29,7 @@ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ } @@ -82,7 +82,7 @@ struct define<> { { if(o.type != type::ARRAY) { throw type_error(); } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; o->via.array.ptr = nullptr; @@ -115,10 +115,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*1)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*1)); o->via.array.size = 1; o->via.array.ptr[0] = object(a0, z); @@ -154,10 +154,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*2)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*2)); o->via.array.size = 2; o->via.array.ptr[0] = object(a0, z); @@ -197,10 +197,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*3)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*3)); o->via.array.size = 3; o->via.array.ptr[0] = object(a0, z); @@ -244,10 +244,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*4)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*4)); o->via.array.size = 4; o->via.array.ptr[0] = object(a0, z); @@ -295,10 +295,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*5)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*5)); o->via.array.size = 5; o->via.array.ptr[0] = object(a0, z); @@ -350,10 +350,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*6)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*6)); o->via.array.size = 6; o->via.array.ptr[0] = object(a0, z); @@ -409,10 +409,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*7)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*7)); o->via.array.size = 7; o->via.array.ptr[0] = object(a0, z); @@ -472,10 +472,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*8)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*8)); o->via.array.size = 8; o->via.array.ptr[0] = object(a0, z); @@ -539,10 +539,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*9)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*9)); o->via.array.size = 9; o->via.array.ptr[0] = object(a0, z); @@ -610,10 +610,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*10)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*10)); o->via.array.size = 10; o->via.array.ptr[0] = object(a0, z); @@ -685,10 +685,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*11)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*11)); o->via.array.size = 11; o->via.array.ptr[0] = object(a0, z); @@ -764,10 +764,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*12)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*12)); o->via.array.size = 12; o->via.array.ptr[0] = object(a0, z); @@ -847,10 +847,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*13)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*13)); o->via.array.size = 13; o->via.array.ptr[0] = object(a0, z); @@ -934,10 +934,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*14)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*14)); o->via.array.size = 14; o->via.array.ptr[0] = object(a0, z); @@ -1025,10 +1025,10 @@ struct define { } } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*15)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*15)); o->via.array.size = 15; o->via.array.ptr[0] = object(a0, z); @@ -1120,10 +1120,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*16)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*16)); o->via.array.size = 16; o->via.array.ptr[0] = object(a0, z); @@ -1219,10 +1219,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*17)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*17)); o->via.array.size = 17; o->via.array.ptr[0] = object(a0, z); @@ -1322,10 +1322,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*18)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*18)); o->via.array.size = 18; o->via.array.ptr[0] = object(a0, z); @@ -1429,10 +1429,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*19)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*19)); o->via.array.size = 19; o->via.array.ptr[0] = object(a0, z); @@ -1540,10 +1540,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*20)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*20)); o->via.array.size = 20; o->via.array.ptr[0] = object(a0, z); @@ -1655,10 +1655,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*21)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*21)); o->via.array.size = 21; o->via.array.ptr[0] = object(a0, z); @@ -1774,10 +1774,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*22)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*22)); o->via.array.size = 22; o->via.array.ptr[0] = object(a0, z); @@ -1897,10 +1897,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*23)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*23)); o->via.array.size = 23; o->via.array.ptr[0] = object(a0, z); @@ -2024,10 +2024,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*24)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*24)); o->via.array.size = 24; o->via.array.ptr[0] = object(a0, z); @@ -2155,10 +2155,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*25)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*25)); o->via.array.size = 25; o->via.array.ptr[0] = object(a0, z); @@ -2290,10 +2290,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*26)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*26)); o->via.array.size = 26; o->via.array.ptr[0] = object(a0, z); @@ -2429,10 +2429,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*27)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*27)); o->via.array.size = 27; o->via.array.ptr[0] = object(a0, z); @@ -2572,10 +2572,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*28)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*28)); o->via.array.size = 28; o->via.array.ptr[0] = object(a0, z); @@ -2719,10 +2719,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*29)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*29)); o->via.array.size = 29; o->via.array.ptr[0] = object(a0, z); @@ -2870,10 +2870,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*30)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*30)); o->via.array.size = 30; o->via.array.ptr[0] = object(a0, z); @@ -3025,10 +3025,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*31)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*31)); o->via.array.size = 31; o->via.array.ptr[0] = object(a0, z); @@ -3184,10 +3184,10 @@ struct definetype = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*32)); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*32)); o->via.array.size = 32; o->via.array.ptr[0] = object(a0, z); diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp index a6685c46..e3c45006 100644 --- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -12274,7 +12274,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*1)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*1)); o.via.array.size = 1; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12285,7 +12285,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*2)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*2)); o.via.array.size = 2; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12297,7 +12297,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*3)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*3)); o.via.array.size = 3; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12310,7 +12310,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*4)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*4)); o.via.array.size = 4; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12324,7 +12324,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*5)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*5)); o.via.array.size = 5; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12339,7 +12339,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*6)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*6)); o.via.array.size = 6; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12355,7 +12355,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*7)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*7)); o.via.array.size = 7; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12372,7 +12372,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*8)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*8)); o.via.array.size = 8; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12390,7 +12390,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*9)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*9)); o.via.array.size = 9; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12409,7 +12409,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*10)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*10)); o.via.array.size = 10; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12429,7 +12429,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*11)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*11)); o.via.array.size = 11; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12450,7 +12450,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*12)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*12)); o.via.array.size = 12; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12472,7 +12472,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*13)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*13)); o.via.array.size = 13; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12495,7 +12495,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*14)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*14)); o.via.array.size = 14; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12519,7 +12519,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*15)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*15)); o.via.array.size = 15; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12544,7 +12544,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*16)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*16)); o.via.array.size = 16; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12570,7 +12570,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*17)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*17)); o.via.array.size = 17; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12597,7 +12597,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*18)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*18)); o.via.array.size = 18; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12625,7 +12625,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*19)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*19)); o.via.array.size = 19; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12654,7 +12654,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*20)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*20)); o.via.array.size = 20; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12684,7 +12684,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*21)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*21)); o.via.array.size = 21; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12715,7 +12715,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*22)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*22)); o.via.array.size = 22; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12747,7 +12747,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*23)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*23)); o.via.array.size = 23; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12780,7 +12780,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*24)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*24)); o.via.array.size = 24; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12814,7 +12814,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*25)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*25)); o.via.array.size = 25; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12849,7 +12849,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*26)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*26)); o.via.array.size = 26; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12885,7 +12885,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*27)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*27)); o.via.array.size = 27; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12922,7 +12922,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*28)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*28)); o.via.array.size = 28; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12960,7 +12960,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*29)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*29)); o.via.array.size = 29; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -12999,7 +12999,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*30)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*30)); o.via.array.size = 30; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -13039,7 +13039,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*31)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*31)); o.via.array.size = 31; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); @@ -13080,7 +13080,7 @@ inline void operator<< ( object::with_zone& o, const type::tuple& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*32)); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*32)); o.via.array.size = 32; o.via.array.ptr[0] = object(v.template get<0>(), o.zone); diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index 9addb54a..712b08cf 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -31,7 +31,7 @@ msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ }\ template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone* z) const \ + void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ { \ msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ } @@ -79,7 +79,7 @@ struct define_imp { if(size <= N-1) { return; } o.via.array.ptr[N-1].convert(std::get(t)); } - static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { + static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) { define_imp::object(o, z, t); o->via.array.ptr[N-1] = msgpack::object(std::get(t), z); } @@ -96,7 +96,7 @@ struct define_imp { if(size <= 0) { return; } o.via.array.ptr[0].convert(std::get<0>(t)); } - static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) { + static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) { o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z); } }; @@ -120,10 +120,10 @@ struct define { define_imp, sizeof...(Args)>::unpack(o, a); } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; - o->via.array.ptr = static_cast(z->allocate_align(sizeof(object)*sizeof...(Args))); + o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*sizeof...(Args))); o->via.array.size = sizeof...(Args); define_imp, sizeof...(Args)>::object(o, z, a); @@ -145,7 +145,7 @@ struct define<> { { if(o.type != type::ARRAY) { throw type_error(); } } - void msgpack_object(msgpack::object* o, msgpack::zone* z) const + void msgpack_object(msgpack::object* o, msgpack::zone& z) const { o->type = type::ARRAY; o->via.array.ptr = NULL; diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index d3ae6cab..7335e12e 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -172,9 +172,9 @@ struct MsgpackTupleToObjectWithZone { template inline void operator<< ( object::with_zone& o, - type::tuple& v) { + type::tuple const& v) { o.type = type::ARRAY; - o.via.array.ptr = static_cast(o.zone->allocate_align(sizeof(object)*sizeof...(Args))); + o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(object)*sizeof...(Args))); o.via.array.size = sizeof...(Args); MsgpackTupleToObjectWithZone::convert(o, v); } diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index 7f5f7085..04633a9d 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::list& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index 464af7e4..ed2fb059 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -78,7 +78,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector& v) o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -134,7 +134,7 @@ inline void operator<< (object::with_zone& o, const std::map& v) o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -184,7 +184,7 @@ inline void operator<< (object::with_zone& o, const std::multimap& v) o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp index 850e17f8..a309cac7 100644 --- a/include/msgpack/adaptor/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -47,7 +47,7 @@ template inline void operator<< (object::with_zone& o, const std::pair& v) { o.type = type::ARRAY; - object* p = static_cast(o.zone->allocate_align(sizeof(object)*2)); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*2)); o.via.array.ptr = p; o.via.array.size = 2; p[0] = object(v.first, o.zone); diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index 098949d9..bea26203 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -56,7 +56,7 @@ inline void operator<< (object::with_zone& o, const std::set& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); @@ -102,7 +102,7 @@ inline void operator<< (object::with_zone& o, const std::multiset& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp index 38b7660a..19964a54 100644 --- a/include/msgpack/adaptor/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -51,7 +51,7 @@ inline packer& operator<< (packer& o, const std::string& v) inline void operator<< (object::with_zone& o, const std::string& v) { o.type = type::STR; - char* ptr = static_cast(o.zone->allocate_align(v.size())); + char* ptr = static_cast(o.zone.allocate_align(v.size())); o.via.str.ptr = ptr; o.via.str.size = static_cast(v.size()); memcpy(ptr, v.data(), v.size()); diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index b18af70f..ebd0d67a 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -77,7 +77,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); @@ -127,7 +127,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.map.ptr = nullptr; o.via.map.size = 0; } else { - object_kv* p = static_cast(o.zone->allocate_align(sizeof(object_kv)*v.size())); + object_kv* p = static_cast(o.zone.allocate_align(sizeof(object_kv)*v.size())); object_kv* const pend = p + v.size(); o.via.map.ptr = p; o.via.map.size = v.size(); diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index 13ae5e51..bf7fc7c8 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -74,7 +74,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); @@ -120,7 +120,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index f33920fb..0123a3b6 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -61,7 +61,7 @@ inline void operator<< (object::with_zone& o, const std::vector& v) o.via.array.ptr = nullptr; o.via.array.size = 0; } else { - object* p = static_cast(o.zone->allocate_align(sizeof(object)*v.size())); + object* p = static_cast(o.zone.allocate_align(sizeof(object)*v.size())); object* const pend = p + v.size(); o.via.array.ptr = p; o.via.array.size = v.size(); diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp index 642e97c6..9ada3e6c 100644 --- a/include/msgpack/adaptor/vector_char.hpp +++ b/include/msgpack/adaptor/vector_char.hpp @@ -60,7 +60,7 @@ inline void operator<< (object& o, const std::vector& v) inline void operator<< (object::with_zone& o, const std::vector& v) { o.type = type::BIN; - char* ptr = static_cast(o.zone->allocate_align(v.size())); + char* ptr = static_cast(o.zone.allocate_align(v.size())); o.via.bin.ptr = ptr; o.via.bin.size = static_cast(v.size()); std::memcpy(ptr, v.data(), v.size()); diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index 7a69f33a..4b05cc23 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -112,6 +112,10 @@ struct object { template explicit object(const T& v); + template + object(const T& v, zone& z); + + // obsolete template object(const T& v, zone* z); @@ -135,8 +139,8 @@ struct object_kv { }; struct object::with_zone : object { - with_zone(msgpack::zone* zone) : zone(zone) { } - msgpack::zone* zone; + with_zone(msgpack::zone& zone) : zone(zone) { } + msgpack::zone& zone; private: with_zone(); }; @@ -367,7 +371,7 @@ inline object& object::operator=(const T& v) } template -object::object(const T& v, zone* z) +object::object(const T& v, zone& z) { with_zone oz(z); oz << v; @@ -375,6 +379,15 @@ object::object(const T& v, zone* z) via = oz.via; } +template +object::object(const T& v, zone* z) +{ + with_zone oz(*z); + oz << v; + type = oz.type; + via = oz.via; +} + inline object::object(msgpack_object o) { diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 4755f2d0..ce1aea91 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -14,6 +14,7 @@ SET (check_PROGRAMS streaming.cpp streaming_c.cpp object.cpp + object_with_zone.cpp version.cpp convert.cpp buffer.cpp diff --git a/test/Makefile.am b/test/Makefile.am index c336e3a6..64b296fd 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -9,6 +9,7 @@ check_PROGRAMS = \ streaming \ streaming_c \ object \ + object_with_zone \ convert \ buffer \ cases \ @@ -35,6 +36,8 @@ streaming_c_SOURCES = streaming_c.cpp object_SOURCES = object.cpp +object_with_zone_SOURCES = object_with_zone.cpp + convert_SOURCES = convert.cpp buffer_SOURCES = buffer.cpp diff --git a/test/buffer.cc b/test/buffer.cc deleted file mode 100644 index 512b0bc4..00000000 --- a/test/buffer.cc +++ /dev/null @@ -1,119 +0,0 @@ -#include -#include -#include -#include -#include -#include - -TEST(buffer, sbuffer) -{ - msgpack::sbuffer sbuf; - sbuf.write("a", 1); - sbuf.write("a", 1); - sbuf.write("a", 1); - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); - - sbuf.clear(); - sbuf.write("a", 1); - sbuf.write("a", 1); - sbuf.write("a", 1); - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); -} - - -TEST(buffer, vrefbuffer) -{ - msgpack::vrefbuffer vbuf; - vbuf.write("a", 1); - vbuf.write("a", 1); - vbuf.write("a", 1); - - const struct iovec* vec = vbuf.vector(); - size_t veclen = vbuf.vector_size(); - - msgpack::sbuffer sbuf; - for(size_t i=0; i < veclen; ++i) { - sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); - } - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); - - - vbuf.clear(); - vbuf.write("a", 1); - vbuf.write("a", 1); - vbuf.write("a", 1); - - vec = vbuf.vector(); - veclen = vbuf.vector_size(); - - sbuf.clear(); - for(size_t i=0; i < veclen; ++i) { - sbuf.write((const char*)vec[i].iov_base, vec[i].iov_len); - } - - EXPECT_EQ(3, sbuf.size()); - EXPECT_TRUE( memcmp(sbuf.data(), "aaa", 3) == 0 ); -} - - -TEST(buffer, zbuffer) -{ - msgpack::zbuffer zbuf; - zbuf.write("a", 1); - zbuf.write("a", 1); - zbuf.write("a", 1); - - zbuf.flush(); -} - - -TEST(buffer, fbuffer) -{ - FILE* file = tmpfile(); - EXPECT_TRUE( file != NULL ); - - msgpack::fbuffer fbuf(file); - EXPECT_EQ(file, fbuf.file()); - - fbuf.write("a", 1); - fbuf.write("a", 1); - fbuf.write("a", 1); - - fflush(file); - rewind(file); - for (size_t i=0; i < 3; ++i) { - int ch = fgetc(file); - EXPECT_TRUE(ch != EOF); - EXPECT_EQ('a', static_cast(ch)); - } - EXPECT_EQ(EOF, fgetc(file)); - fclose(file); -} - - -TEST(buffer, fbuffer_c) -{ - FILE* file = tmpfile(); - void* fbuf = (void*)file; - - EXPECT_TRUE( file != NULL ); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - EXPECT_EQ(0, msgpack_fbuffer_write(fbuf, "a", 1)); - - fflush(file); - rewind(file); - for (size_t i=0; i < 3; ++i) { - int ch = fgetc(file); - EXPECT_TRUE(ch != EOF); - EXPECT_EQ('a', (char) ch); - } - EXPECT_EQ(EOF, fgetc(file)); - fclose(file); -} diff --git a/test/cases.cc b/test/cases.cc deleted file mode 100644 index 45aace0b..00000000 --- a/test/cases.cc +++ /dev/null @@ -1,38 +0,0 @@ -#include -#include -#include - -static void feed_file(msgpack::unpacker& pac, const char* path) -{ - std::ifstream fin(path); - while(true) { - pac.reserve_buffer(32*1024); - fin.read(pac.buffer(), pac.buffer_capacity()); - if(fin.bad()) { - throw std::runtime_error("read failed"); - } - pac.buffer_consumed(fin.gcount()); - if(fin.fail()) { - break; - } - } -} - -TEST(cases, format) -{ - msgpack::unpacker pac; - msgpack::unpacker pac_compact; - - feed_file(pac, "cases.mpac"); - feed_file(pac_compact, "cases_compact.mpac"); - - msgpack::unpacked result; - while(pac.next(&result)) { - msgpack::unpacked result_compact; - EXPECT_TRUE( pac_compact.next(&result_compact) ); - EXPECT_EQ(result_compact.get(), result.get()); - } - - EXPECT_FALSE( pac_compact.next(&result) ); -} - diff --git a/test/convert.cc b/test/convert.cc deleted file mode 100644 index dcda77c6..00000000 --- a/test/convert.cc +++ /dev/null @@ -1,76 +0,0 @@ -#include -#include - -class compatibility { -public: - compatibility() : str1("default"), str2("default") { } - - std::string str1; - std::string str2; - - MSGPACK_DEFINE(str1, str2); -}; - -TEST(convert, compatibility_less) -{ - std::vector src(1); - src[0] = "kumofs"; - - msgpack::zone z; - msgpack::object obj(src, &z); - - compatibility c; - EXPECT_NO_THROW( obj.convert(&c) ); - - EXPECT_EQ("kumofs", c.str1); - EXPECT_EQ("default", c.str2); -} - -TEST(convert, compatibility_more) -{ - std::vector src(3); - src[0] = "kumofs"; - src[1] = "mpio"; - src[2] = "cloudy"; - - msgpack::zone z; - msgpack::object obj(src, &z); - - compatibility to; - EXPECT_NO_THROW( obj.convert(&to) ); - - EXPECT_EQ("kumofs", to.str1); - EXPECT_EQ("mpio", to.str2); -} - - -class enum_member { -public: - enum_member() : flag(A) { } - - enum flags_t { - A = 0, - B = 1 - }; - - flags_t flag; - - MSGPACK_DEFINE(flag); -}; - -MSGPACK_ADD_ENUM(enum_member::flags_t); - -TEST(convert, enum_member) -{ - enum_member src; - src.flag = enum_member::B; - - msgpack::zone z; - msgpack::object obj(src, &z); - - enum_member to; - EXPECT_NO_THROW( obj.convert(&to) ); - - EXPECT_EQ(enum_member::B, to.flag); -} - diff --git a/test/fixint.cc b/test/fixint.cc deleted file mode 100644 index cf109ae5..00000000 --- a/test/fixint.cc +++ /dev/null @@ -1,55 +0,0 @@ -#include -#include - -template -void check_size(size_t size) { - T v(0); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, v); - EXPECT_EQ(size, sbuf.size()); -} - -TEST(fixint, size) -{ - check_size(2); - check_size(3); - check_size(5); - check_size(9); - - check_size(2); - check_size(3); - check_size(5); - check_size(9); -} - - -template -void check_convert() { - T v1(-11); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, v1); - - msgpack::unpacked msg; - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); - - T v2; - msg.get().convert(&v2); - - EXPECT_EQ(v1.get(), v2.get()); - - EXPECT_EQ(msg.get(), msgpack::object(T(v1.get()))); -} - -TEST(fixint, convert) -{ - check_convert(); - check_convert(); - check_convert(); - check_convert(); - - check_convert(); - check_convert(); - check_convert(); - check_convert(); -} - diff --git a/test/fixint_c.cc b/test/fixint_c.cc deleted file mode 100644 index d9dc5180..00000000 --- a/test/fixint_c.cc +++ /dev/null @@ -1,32 +0,0 @@ -#include -#include - -TEST(fixint, size) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - size_t sum = 0; - - EXPECT_EQ(0, msgpack_pack_fix_int8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_int64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); - - EXPECT_EQ(0, msgpack_pack_fix_uint8(pk, 0)); - EXPECT_EQ(sum+=2, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint16(pk, 0)); - EXPECT_EQ(sum+=3, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint32(pk, 0)); - EXPECT_EQ(sum+=5, sbuf->size); - EXPECT_EQ(0, msgpack_pack_fix_uint64(pk, 0)); - EXPECT_EQ(sum+=9, sbuf->size); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - diff --git a/test/msgpack_tuple.cc b/test/msgpack_tuple.cc deleted file mode 100644 index 9779d06a..00000000 --- a/test/msgpack_tuple.cc +++ /dev/null @@ -1,103 +0,0 @@ -#include -#include - - -TEST(msgpack_tuple, member_get) -{ - msgpack::type::tuple t1(42, true, "ABC"); - EXPECT_EQ(42, t1.get<0>()); - EXPECT_EQ(true, t1.get<1>()); - EXPECT_EQ("ABC", t1.get<2>()); - t1.get<0>() = 40; - t1.get<1>() = false; - t1.get<2>() = "DEFG"; - EXPECT_EQ(40, t1.get<0>()); - EXPECT_EQ(false, t1.get<1>()); - EXPECT_EQ("DEFG", t1.get<2>()); -} - -TEST(msgpack_tuple, non_member_get) -{ - msgpack::type::tuple t1(42, true, "ABC"); - EXPECT_EQ(42, msgpack::type::get<0>(t1)); - EXPECT_EQ(true, msgpack::type::get<1>(t1)); - EXPECT_EQ("ABC", msgpack::type::get<2>(t1)); - msgpack::type::get<0>(t1) = 40; - msgpack::type::get<1>(t1) = false; - msgpack::type::get<2>(t1) = "DEFG"; - EXPECT_EQ(40, msgpack::type::get<0>(t1)); - EXPECT_EQ(false, msgpack::type::get<1>(t1)); - EXPECT_EQ("DEFG", msgpack::type::get<2>(t1)); -} - -#if __cplusplus >= 201103 -TEST(msgpack_tuple, std_non_member_get) -{ - msgpack::type::tuple t1(42, true, "ABC"); - EXPECT_EQ(42, std::get<0>(t1)); - EXPECT_EQ(true, std::get<1>(t1)); - EXPECT_EQ("ABC", std::get<2>(t1)); - std::get<0>(t1) = 40; - std::get<1>(t1) = false; - std::get<2>(t1) = "DEFG"; - EXPECT_EQ(40, std::get<0>(t1)); - EXPECT_EQ(false, std::get<1>(t1)); - EXPECT_EQ("DEFG", std::get<2>(t1)); -} - -TEST(msgpack_tuple, make_tuple) -{ - msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); - EXPECT_EQ(42, t1.get<0>()); - EXPECT_EQ(true, t1.get<1>()); - EXPECT_EQ("ABC", t1.get<2>()); - t1.get<0>() = 40; - t1.get<1>() = false; - t1.get<2>() = "DEFG"; - EXPECT_EQ(40, t1.get<0>()); - EXPECT_EQ(false, t1.get<1>()); - EXPECT_EQ("DEFG", t1.get<2>()); -} - -TEST(msgpack_tuple, std_make_tuple) -{ - msgpack::type::tuple t1 = std::make_tuple(42, true, "ABC"); - EXPECT_EQ(42, t1.get<0>()); - EXPECT_EQ(true, t1.get<1>()); - EXPECT_EQ("ABC", t1.get<2>()); -} - -TEST(msgpack_tuple, tie) -{ - int i(43); - bool b(false); - std::string s("DEFG"); - msgpack::type::tie(i, b, s) = msgpack::type::make_tuple(42, true, "ABC"); - EXPECT_EQ(42, i); - EXPECT_EQ(true, b); - EXPECT_EQ("ABC", s); -} - -TEST(msgpack_tuple, tuple_cat) -{ - msgpack::type::tuple t1 = msgpack::type::make_tuple(42); - msgpack::type::tuple t2 = msgpack::type::make_tuple(true, "ABC"); - msgpack::type::tuple t3 = msgpack::type::tuple_cat(t1, std::move(t2)); - EXPECT_EQ(42, t3.get<0>()); - EXPECT_EQ(true, t3.get<1>()); - EXPECT_EQ("ABC", t3.get<2>()); -} - -TEST(msgpack_tuple, swap) -{ - msgpack::type::tuple t1 = msgpack::type::make_tuple(42, true, "ABC"); - msgpack::type::tuple t2 = msgpack::type::make_tuple(40, false, "DEFG"); - msgpack::type::swap(t1, t2); - EXPECT_EQ(42, t2.get<0>()); - EXPECT_EQ(true, t2.get<1>()); - EXPECT_EQ("ABC", t2.get<2>()); - EXPECT_EQ(40, t1.get<0>()); - EXPECT_EQ(false, t1.get<1>()); - EXPECT_EQ("DEFG", t1.get<2>()); -} -#endif diff --git a/test/object.cc b/test/object.cc deleted file mode 100644 index 88490fb5..00000000 --- a/test/object.cc +++ /dev/null @@ -1,125 +0,0 @@ -#include -#include - -struct myclass { - myclass() : num(0), str("default") { } - - myclass(int num, const std::string& str) : - num(0), str("default") { } - - ~myclass() { } - - int num; - std::string str; - - MSGPACK_DEFINE(num, str); - - bool operator==(const myclass& o) const - { - return num == o.num && str == o.str; - } -}; - -std::ostream& operator<<(std::ostream& o, const myclass& m) -{ - return o << "myclass("<()); -} - - -TEST(object, print) -{ - msgpack::object obj; - std::cout << obj << std::endl; -} - - -TEST(object, is_nil) -{ - msgpack::object obj; - EXPECT_TRUE(obj.is_nil()); -} - - -TEST(object, type_error) -{ - msgpack::object obj(1); - EXPECT_THROW(obj.as(), msgpack::type_error); - EXPECT_THROW(obj.as >(), msgpack::type_error); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1, obj.as()); - EXPECT_EQ(1u, obj.as()); - EXPECT_EQ(1u, obj.as()); -} - - -TEST(object, equal_primitive) -{ - msgpack::object obj_nil; - EXPECT_EQ(obj_nil, msgpack::object()); - - msgpack::object obj_int(1); - EXPECT_EQ(obj_int, msgpack::object(1)); - EXPECT_EQ(obj_int, 1); - - msgpack::object obj_double(1.2); - EXPECT_EQ(obj_double, msgpack::object(1.2)); - EXPECT_EQ(obj_double, 1.2); - - msgpack::object obj_bool(true); - EXPECT_EQ(obj_bool, msgpack::object(true)); - EXPECT_EQ(obj_bool, true); -} - - -TEST(object, construct_primitive) -{ - msgpack::object obj_nil; - EXPECT_EQ(msgpack::type::NIL, obj_nil.type); - - msgpack::object obj_uint(1); - EXPECT_EQ(msgpack::type::POSITIVE_INTEGER, obj_uint.type); - EXPECT_EQ(1u, obj_uint.via.u64); - - msgpack::object obj_int(-1); - EXPECT_EQ(msgpack::type::NEGATIVE_INTEGER, obj_int.type); - EXPECT_EQ(-1, obj_int.via.i64); - - msgpack::object obj_double(1.2); - EXPECT_EQ(msgpack::type::DOUBLE, obj_double.type); - EXPECT_EQ(1.2, obj_double.via.dec); - - msgpack::object obj_bool(true); - EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type); - EXPECT_EQ(true, obj_bool.via.boolean); -} diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp new file mode 100644 index 00000000..123e570c --- /dev/null +++ b/test/object_with_zone.cpp @@ -0,0 +1,662 @@ +#include +#include +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +// bool +TEST(object_with_zone, bool) +{ + bool v = true; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = false; + EXPECT_TRUE(obj.as()); +} + +// char +TEST(object_with_zone, char) +{ + char v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +// signed integer family +TEST(object_with_zone, signed_char) +{ + signed char v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_short) +{ + signed short v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_int) +{ + signed int v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_long) +{ + signed long v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +TEST(object_with_zone, signed_long_long) +{ + signed long long v = -1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = -2; + EXPECT_EQ(obj.as(), -1); +} + +// unsigned integer family +TEST(object_with_zone, unsigned_char) +{ + unsigned char v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_short) +{ + unsigned short v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_int) +{ + unsigned int v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_long) +{ + unsigned long v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +TEST(object_with_zone, unsigned_long_long) +{ + unsigned long long v = 1; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v = 2; + EXPECT_EQ(obj.as(), 1); +} + +// float +TEST(object_with_zone, float) +{ + float v = 1.23; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_TRUE(fabs(obj.as() - v) <= kEPS); + v = 4.56; + EXPECT_TRUE(fabs(obj.as() - static_cast(1.23)) <= kEPS); +} + +// double +TEST(object_with_zone, double) +{ + double v = 1.23; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_TRUE(fabs(obj.as() - v) <= kEPS); + v = 4.56; + EXPECT_TRUE(fabs(obj.as() - 1.23) <= kEPS); +} + +// vector + +TEST(object_with_zone, vector) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +// vector_char +TEST(object_with_zone, vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(static_cast(i)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +TEST(object_without_zone, vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(static_cast(i)); + msgpack::object obj(v1); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + // obj refer to v1 + EXPECT_EQ(obj.as >().front(), 42); + } +} + +// list +TEST(object_with_zone, list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + list v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +// deque +TEST(object_with_zone, deque) +{ + for (unsigned int k = 0; k < kLoop; k++) { + deque v1; + v1.push_back(1); + for (unsigned int i = 1; i < kElements; i++) + v1.push_back(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), 1); + } +} + +// string +TEST(object_with_zone, string) +{ + string v = "abc"; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'a'); +} + +TEST(object_without_zone, string) +{ + string v = "abc"; + msgpack::zone z; + msgpack::object obj(v); + EXPECT_EQ(obj.as(), v); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'd'); +} + +// raw_ref +TEST(object_with_zone, raw_ref) +{ + string s = "abc"; + msgpack::type::raw_ref v(s.data(), s.size()); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + s[0] = 'd'; + // even if with_zone, not copied due to raw_ref + // Basically, the combination raw_ref and object::wit_zone + // is meaningless. + EXPECT_EQ(obj.as(), v); +} + +TEST(object_without_zone, raw_ref) +{ + string s = "abc"; + msgpack::type::raw_ref v(s.data(), s.size()); + msgpack::zone z; + msgpack::object obj(v); + EXPECT_EQ(obj.as(), v); + s[0] = 'd'; + EXPECT_EQ(obj.as(), v); +} + +// pair +TEST(object_with_zone, pair) +{ + typedef pair test_t; + test_t v(1, "abc"); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); + v.first = 42; + EXPECT_EQ(obj.as().first, 1); +} + +// set +TEST(object_with_zone, set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + set v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + } +} + +// multiset +TEST(object_with_zone, multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multiset v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(i % (kElements / 2)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + } +} + +// map +TEST(object_with_zone, map) +{ + typedef map test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(std::make_pair(i, i*2)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + } +} + +// multimap +TEST(object_with_zone, multimap) +{ + typedef multimap test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(std::make_pair(i % (kElements / 2), i*2)); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + } +} + +// msgpack_tuple +TEST(object_with_zone, msgpack_tuple) +{ + typedef msgpack::type::tuple test_t; + test_t v(1, "abc", true); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(msgpack::type::get<0>(obj.as()), 1); + EXPECT_EQ(msgpack::type::get<1>(obj.as()), "abc"); + EXPECT_EQ(msgpack::type::get<2>(obj.as()), true); + msgpack::type::get<0>(v) = 42; + EXPECT_EQ(msgpack::type::get<0>(obj.as()), 1); +} + +// TR1 + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(object_with_zone, tr1_unordered_map) +{ + typedef tr1::unordered_map test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1[rand()] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + test_t::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) { + EXPECT_TRUE(v2.find(it->first) != v2.end()); + EXPECT_EQ(it->second, v2.find(it->first)->second); + } + } +} + + +TEST(object_with_zone, tr1_unordered_multimap) +{ + typedef tr1::unordered_multimap test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(make_pair(i1, rand())); + v1.insert(make_pair(i1, rand())); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector > vec1, vec2; + tr1::unordered_multimap::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(make_pair(it->first, it->second)); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(object_with_zone, tr1_unordered_set) +{ + typedef tr1::unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(rand()); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + tr1::unordered_set::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + EXPECT_TRUE(v2.find(*it) != v2.end()); + } +} + +TEST(object_with_zone, tr1_unordered_multiset) +{ + typedef tr1::unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(i1); + v1.insert(i1); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector vec1, vec2; + tr1::unordered_multiset::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(*it); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(*it); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(object_with_zone, unordered_map) +{ + typedef unordered_map test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1[rand()] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + test_t::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) { + EXPECT_TRUE(v2.find(it->first) != v2.end()); + EXPECT_EQ(it->second, v2.find(it->first)->second); + } + } +} + +TEST(object_with_zone, unordered_multimap) +{ + typedef unordered_multimap test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(make_pair(i1, rand())); + v1.insert(make_pair(i1, rand())); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector > vec1, vec2; + tr1::unordered_multimap::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(make_pair(it->first, it->second)); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(object_with_zone, unordered_set) +{ + typedef unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) + v1.insert(rand()); + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + EXPECT_EQ(v1.size(), v2.size()); + tr1::unordered_set::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + EXPECT_TRUE(v2.find(*it) != v2.end()); + } +} + +TEST(object_with_zone, unordered_multiset) +{ + typedef unordered_set test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + v1.insert(i1); + v1.insert(i1); + } + msgpack::zone z; + msgpack::object obj(v1, z); + test_t v2 = obj.as(); + vector vec1, vec2; + tr1::unordered_multiset::const_iterator it; + for (it = v1.begin(); it != v1.end(); ++it) + vec1.push_back(*it); + for (it = v2.begin(); it != v2.end(); ++it) + vec2.push_back(*it); + EXPECT_EQ(v1.size(), v2.size()); + EXPECT_EQ(vec1.size(), vec2.size()); + sort(vec1.begin(), vec1.end()); + sort(vec2.begin(), vec2.end()); + EXPECT_TRUE(vec1 == vec2); + } +} +#endif + +// User defined class +class TestClass +{ +public: + TestClass() : i(0), s("kzk") {} + int i; + string s; + MSGPACK_DEFINE(i, s); +}; + +TEST(object_with_zone, user_defined) +{ + TestClass v1; + msgpack::zone z; + msgpack::object obj(v1, z); + TestClass v2 = obj.as(); + EXPECT_EQ(v1.i, v2.i); + EXPECT_EQ(v1.s, v2.s); +} + +#if !defined(MSGPACK_USE_CPP03) + +TEST(object_with_zone, array) +{ + typedef array test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + v1[0] = 1; + for (unsigned int i = 1; i < kElements; i++) + v1[i] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as().front(), 1); + } +} + +TEST(object_with_zone, array_char) +{ + typedef array test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + v1[0] = 1; + for (unsigned int i = 1; i < kElements; i++) + v1[i] = rand(); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as().front(), 1); + } +} + +TEST(object_without_zone, array_char) +{ + typedef array test_t; + for (unsigned int k = 0; k < kLoop; k++) { + test_t v1; + v1[0] = 1; + for (unsigned int i = 1; i < kElements; i++) + v1[i] = rand(); + msgpack::object obj(v1); + EXPECT_EQ(obj.as(), v1); + v1.front() = 42; + // obj refer to v1 + EXPECT_EQ(obj.as().front(), 42); + } +} + + +TEST(object_with_zone, forward_list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + forward_list v1; + for (unsigned int i = 0; i < kElements; i++) + v1.push_front(i); + msgpack::zone z; + msgpack::object obj(v1, z); + EXPECT_EQ(obj.as >(), v1); + v1.front() = 42; + EXPECT_EQ(obj.as >().front(), kElements - 1); + } +} + +TEST(object_with_zone, tuple) +{ + typedef tuple test_t; + test_t v(1, "abc", true); + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); +} + +#endif + diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc deleted file mode 100644 index b95bccde..00000000 --- a/test/pack_unpack.cc +++ /dev/null @@ -1,132 +0,0 @@ -#include -#include -#include - -TEST(pack, num) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); -} - - -TEST(pack, vector) -{ - msgpack::sbuffer sbuf; - std::vector vec; - vec.push_back(1); - vec.push_back(2); - vec.push_back(3); - msgpack::pack(sbuf, vec); -} - - -TEST(pack, to_ostream) -{ - std::ostringstream stream; - msgpack::pack(stream, 1); -} - - -struct myclass { - myclass() : num(0), str("default") { } - - myclass(int num, const std::string& str) : - num(num), str(str) { } - - ~myclass() { } - - int num; - std::string str; - - MSGPACK_DEFINE(num, str); -}; - - -TEST(pack, myclass) -{ - msgpack::sbuffer sbuf; - myclass m(1, "msgpack"); - msgpack::pack(sbuf, m); -} - -TEST(unpack, int_no_offset) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::unpacked msg; - - msgpack::unpack(msg, sbuf.data(), sbuf.size()); - EXPECT_EQ(1, msg.get().as()); -} - -TEST(unpack, int_offset) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::unpacked msg; - - std::size_t off = 0; - - msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); - EXPECT_EQ(1, msg.get().as()); - EXPECT_EQ(off, sbuf.size()); -} - -TEST(unpack, int_pointer) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::unpacked msg; - - std::size_t off = 0; - - // obsolete - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off); - EXPECT_EQ(1, msg.get().as()); - EXPECT_EQ(off, sbuf.size()); -} - -TEST(unpack, int_null_pointer) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::unpacked msg; - - // obsolete - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr); - EXPECT_EQ(1, msg.get().as()); -} - -TEST(unpack, int_default_null_pointer) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::unpacked msg; - - // obsolete - msgpack::unpack(&msg, sbuf.data(), sbuf.size()); - EXPECT_EQ(1, msg.get().as()); -} - -TEST(unpack, sequence) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::pack(sbuf, 2); - msgpack::pack(sbuf, 3); - - std::size_t off = 0; - - msgpack::unpacked msg; - - msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); - EXPECT_EQ(1, msg.get().as()); - - msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); - EXPECT_EQ(2, msg.get().as()); - - msgpack::unpack(msg, sbuf.data(), sbuf.size(), off); - EXPECT_EQ(3, msg.get().as()); - - EXPECT_EQ(off, sbuf.size()); -} diff --git a/test/pack_unpack_c.cc b/test/pack_unpack_c.cc deleted file mode 100644 index 60e0e00e..00000000 --- a/test/pack_unpack_c.cc +++ /dev/null @@ -1,70 +0,0 @@ -#include -#include -#include - -TEST(pack, num) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - - -TEST(pack, array) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_array(pk, 3)); - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - - msgpack_sbuffer_free(sbuf); - msgpack_packer_free(pk); -} - - -TEST(unpack, sequence) -{ - msgpack_sbuffer* sbuf = msgpack_sbuffer_new(); - msgpack_packer* pk = msgpack_packer_new(sbuf, msgpack_sbuffer_write); - - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - - msgpack_packer_free(pk); - - bool success; - size_t offset = 0; - - msgpack_unpacked msg; - msgpack_unpacked_init(&msg); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(1, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(2, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_TRUE(success); - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, msg.data.type); - EXPECT_EQ(3, msg.data.via.u64); - - success = msgpack_unpack_next(&msg, sbuf->data, sbuf->size, &offset); - EXPECT_FALSE(success); - - msgpack_sbuffer_free(sbuf); - msgpack_unpacked_destroy(&msg); -} - diff --git a/test/reference.cc b/test/reference.cc deleted file mode 100644 index 09ecbca5..00000000 --- a/test/reference.cc +++ /dev/null @@ -1,434 +0,0 @@ -#include -#include - -TEST(reference, unpack_int) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::unpacked ret; - - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); -} - -TEST(reference, unpack_string) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, std::string("abcdefg")); - msgpack::unpacked ret; - - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); -} - -TEST(reference, unpack_bin) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char c[] = { 1, 2, 3, 4, 5, 6 }; - packer.pack_bin(sizeof(c)); - packer.pack_bin_body(c, sizeof(c)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); -} - -TEST(reference, unpack_ext) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); -} - -bool never_called(msgpack::type::object_type, std::size_t, void*) -{ - EXPECT_TRUE(false); - return false; -} - -bool always_reference(msgpack::type::object_type, std::size_t, void*) -{ - return true; -} - -TEST(reference, unpack_int_ref) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - msgpack::unpacked ret; - - msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called); - EXPECT_FALSE(ret.referenced()); -} - -TEST(reference, unpack_string_ref) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, std::string("abcdefg")); - msgpack::unpacked ret; - - msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); - EXPECT_TRUE(ret.referenced()); -} - -TEST(reference, unpack_bin_ref) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char c[] = { 1, 2, 3, 4, 5, 6 }; - packer.pack_bin(sizeof(c)); - packer.pack_bin_body(c, sizeof(c)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); - EXPECT_TRUE(ret.referenced()); -} - -TEST(reference, unpack_ext_ref) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); - EXPECT_TRUE(ret.referenced()); -} - -static void* s_p; - -bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p) -{ - s_p = p; - switch (t) { - case msgpack::type::STR: - if (s >= 5) return true; - break; - case msgpack::type::BIN: - if (s >= 6) return true; - break; - case msgpack::type::EXT: - if (s >= 7) return true; - break; - default: - EXPECT_TRUE(false); - } - return false; -} - -TEST(reference, unpack_int_sized_ref) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - - msgpack::unpacked ret; - s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf); - EXPECT_FALSE(ret.referenced()); - EXPECT_EQ(nullptr, s_p); -} - -TEST(reference, unpack_string_sized_ref_4) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, std::string("1234")); - - msgpack::unpacked ret; - s_p = nullptr; - // the last argument sbuf is any pointer as a user data. - // That is stored to s_p in sized_reference - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_FALSE(ret.referenced()); - // compare the passed argument with stored s_p. - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpack_string_sized_ref_5) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, std::string("12345")); - - msgpack::unpacked ret; - s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_TRUE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - - -TEST(reference, unpack_bin_sized_ref_5) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char c[] = { 1, 2, 3, 4, 5 }; - packer.pack_bin(sizeof(c)); - packer.pack_bin_body(c, sizeof(c)); - - msgpack::unpacked ret; - s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_FALSE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpack_bin_sized_ref_6) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char c[] = { 1, 2, 3, 4, 5, 6 }; - packer.pack_bin(sizeof(c)); - packer.pack_bin_body(c, sizeof(c)); - - msgpack::unpacked ret; - s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_TRUE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpack_ext_sized_ref_6) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 1, 2, 3, 4, 5 }; - - packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_FALSE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpack_ext_sized_ref_7) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 1, 2, 3, 4, 5, 6 }; - - packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_TRUE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -// default reference function -// STR, BIN, and EXT are always referenced, otherwise copied (converted). - -TEST(reference, unpacker_int) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - - msgpack::unpacker unp; - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); -} - -TEST(reference, unpacker_string) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, std::string("a")); - - msgpack::unpacker unp; - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); -} - -TEST(reference, unpacker_bin) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char c[] = { 1 }; - packer.pack_bin(sizeof(c)); - packer.pack_bin_body(c, sizeof(c)); - - msgpack::unpacker unp; - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); -} - -TEST(reference, unpacker_ext) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacker unp; - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); -} - -// pass user custom reference function - -TEST(reference, unpacker_int_sized_ref) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, 1); - - msgpack::unpacker unp(never_called, &sbuf); - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - s_p = nullptr; - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); - EXPECT_EQ(nullptr, s_p); -} - -TEST(reference, unpacker_string_sized_ref_4) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, std::string("1234")); - - msgpack::unpacker unp(sized_reference, &sbuf); - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - s_p = nullptr; - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpacker_string_sized_ref_5) -{ - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, std::string("12345")); - - msgpack::unpacker unp(sized_reference, &sbuf); - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - s_p = nullptr; - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - - -TEST(reference, unpacker_bin_sized_ref_5) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char c[] = { 1, 2, 3, 4, 5 }; - packer.pack_bin(sizeof(c)); - packer.pack_bin_body(c, sizeof(c)); - - msgpack::unpacker unp(sized_reference, &sbuf); - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - s_p = nullptr; - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpacker_bin_sized_ref_6) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char c[] = { 1, 2, 3, 4, 5, 6 }; - packer.pack_bin(sizeof(c)); - packer.pack_bin_body(c, sizeof(c)); - - msgpack::unpacker unp(sized_reference, &sbuf); - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - s_p = nullptr; - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpacker_ext_sized_ref_6) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 1, 2, 3, 4, 5 }; - - packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacker unp(sized_reference, &sbuf); - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - s_p = nullptr; - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} - -TEST(reference, unpacker_ext_sized_ref_7) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 1, 2, 3, 4, 5, 6 }; - - packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacker unp(sized_reference, &sbuf); - msgpack::unpacked ret; - unp.reserve_buffer(sbuf.size()); - std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); - unp.buffer_consumed(sbuf.size()); - s_p = nullptr; - bool b = unp.next(ret); - EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); - EXPECT_EQ(&sbuf, s_p); -} diff --git a/test/streaming.cc b/test/streaming.cc deleted file mode 100644 index 2daa98a1..00000000 --- a/test/streaming.cc +++ /dev/null @@ -1,316 +0,0 @@ -#include -#include -#include - -TEST(streaming, basic) -{ - msgpack::sbuffer buffer; - - msgpack::packer pk(&buffer); - pk.pack(1); - pk.pack(2); - pk.pack(3); - - const char* input = buffer.data(); - const char* const eof = input + buffer.size(); - - msgpack::unpacker pac; - msgpack::unpacked result; - - int count = 0; - while(count < 3) { - pac.reserve_buffer(32*1024); - - // read buffer into pac.buffer() upto - // pac.buffer_capacity() bytes. - size_t len = 1; - memcpy(pac.buffer(), input, len); - input += len; - - pac.buffer_consumed(len); - - while(pac.next(result)) { - msgpack::object obj = result.get(); - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } - } - - EXPECT_TRUE(input < eof); - } -} - -TEST(streaming, basic_pointer) -{ - msgpack::sbuffer buffer; - - msgpack::packer pk(&buffer); - pk.pack(1); - pk.pack(2); - pk.pack(3); - - const char* input = buffer.data(); - const char* const eof = input + buffer.size(); - - msgpack::unpacker pac; - msgpack::unpacked result; - - int count = 0; - while(count < 3) { - pac.reserve_buffer(32*1024); - - // read buffer into pac.buffer() upto - // pac.buffer_capacity() bytes. - size_t len = 1; - memcpy(pac.buffer(), input, len); - input += len; - - pac.buffer_consumed(len); - - while(pac.next(&result)) { - msgpack::object obj = result.get(); - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } - } - - EXPECT_TRUE(input < eof); - } -} - -#if !defined(MSGPACK_USE_CPP03) - -TEST(streaming, move) -{ - msgpack::sbuffer buffer; - - msgpack::packer pk(&buffer); - pk.pack(1); - pk.pack(2); - pk.pack(3); - - const char* input = buffer.data(); - const char* const eof = input + buffer.size(); - - msgpack::unpacker pac; - msgpack::unpacked result; - - int count = 0; - while(count < 3) { - msgpack::unpacker pac_in(std::move(pac)); - pac_in.reserve_buffer(32*1024); - - // read buffer into pac_in.buffer() upto - // pac_in.buffer_capac_inity() bytes. - size_t len = 1; - memcpy(pac_in.buffer(), input, len); - input += len; - - pac_in.buffer_consumed(len); - - while(pac_in.next(result)) { - msgpack::object obj = result.get(); - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } - } - - EXPECT_TRUE(input < eof); - pac = std::move(pac_in); - } -} - -#endif // !defined(MSGPACK_USE_CPP03) - -class event_handler { -public: - event_handler(std::istream& input) : input(input) { } - ~event_handler() { } - - void on_read() - { - while(true) { - pac.reserve_buffer(32*1024); - - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - - if(len == 0) { - return; - } - - pac.buffer_consumed(len); - - msgpack::unpacked result; - while(pac.next(result)) { - on_message(result.get(), msgpack::move(result.zone())); - } - - if(pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } - } - - void on_message(msgpack::object obj, msgpack::unique_ptr z) - { - EXPECT_EQ(expect, obj.as()); - } - - int expect; - -private: - std::istream& input; - msgpack::unpacker pac; -}; - -TEST(streaming, event) -{ - std::stringstream stream; - msgpack::packer pk(&stream); - - event_handler handler(stream); - - pk.pack(1); - handler.expect = 1; - handler.on_read(); - - pk.pack(2); - handler.expect = 2; - handler.on_read(); - - pk.pack(3); - handler.expect = 3; - handler.on_read(); -} - - -// backward compatibility -TEST(streaming, basic_compat) -{ - std::ostringstream stream; - msgpack::packer pk(&stream); - - pk.pack(1); - pk.pack(2); - pk.pack(3); - - std::istringstream input(stream.str()); - - msgpack::unpacker pac; - - int count = 0; - while(count < 3) { - pac.reserve_buffer(32*1024); - - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - pac.buffer_consumed(len); - - while(pac.execute()) { - msgpack::unique_ptr z(pac.release_zone()); - msgpack::object obj = pac.data(); - pac.reset(); - - switch(count++) { - case 0: - EXPECT_EQ(1, obj.as()); - break; - case 1: - EXPECT_EQ(2, obj.as()); - break; - case 2: - EXPECT_EQ(3, obj.as()); - return; - } - - } - } -} - - -// backward compatibility -class event_handler_compat { -public: - event_handler_compat(std::istream& input) : input(input) { } - ~event_handler_compat() { } - - void on_read() - { - while(true) { - pac.reserve_buffer(32*1024); - - size_t len = input.readsome(pac.buffer(), pac.buffer_capacity()); - - if(len == 0) { - return; - } - - pac.buffer_consumed(len); - - while(pac.execute()) { - msgpack::unique_ptr z(pac.release_zone()); - msgpack::object obj = pac.data(); - pac.reset(); - on_message(obj, msgpack::move(z)); - } - - if(pac.message_size() > 10*1024*1024) { - throw std::runtime_error("message is too large"); - } - } - } - - void on_message(msgpack::object obj, msgpack::unique_ptr z) - { - EXPECT_EQ(expect, obj.as()); - } - - int expect; - -private: - std::istream& input; - msgpack::unpacker pac; -}; - -TEST(streaming, event_compat) -{ - std::stringstream stream; - msgpack::packer pk(&stream); - - event_handler_compat handler(stream); - - pk.pack(1); - handler.expect = 1; - handler.on_read(); - - pk.pack(2); - handler.expect = 2; - handler.on_read(); - - pk.pack(3); - handler.expect = 3; - handler.on_read(); -} diff --git a/test/streaming_c.cc b/test/streaming_c.cc deleted file mode 100644 index 159eef76..00000000 --- a/test/streaming_c.cc +++ /dev/null @@ -1,114 +0,0 @@ -#include -#include -#include - -TEST(streaming, basic) -{ - msgpack_sbuffer* buffer = msgpack_sbuffer_new(); - - msgpack_packer* pk = msgpack_packer_new(buffer, msgpack_sbuffer_write); - - // 1, 2, 3, "str", ["str_data"], "bin", ["bin_data"], {0.3: 0.4} - EXPECT_EQ(0, msgpack_pack_int(pk, 1)); - EXPECT_EQ(0, msgpack_pack_int(pk, 2)); - EXPECT_EQ(0, msgpack_pack_int(pk, 3)); - EXPECT_EQ(0, msgpack_pack_str(pk, 3)); - EXPECT_EQ(0, msgpack_pack_str_body(pk, "str", 3)); - EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_str(pk, 8)); - EXPECT_EQ(0, msgpack_pack_str_body(pk, "str_data", 8)); - EXPECT_EQ(0, msgpack_pack_bin(pk, 3)); - EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin", 3)); - EXPECT_EQ(0, msgpack_pack_array(pk, 1)); - EXPECT_EQ(0, msgpack_pack_bin(pk, 8)); - EXPECT_EQ(0, msgpack_pack_bin_body(pk, "bin_data", 8)); - EXPECT_EQ(0, msgpack_pack_map(pk, 1)); - EXPECT_EQ(0, msgpack_pack_float(pk, 0.4)); - EXPECT_EQ(0, msgpack_pack_double(pk, 0.8)); - int max_count = 6; - - msgpack_packer_free(pk); - - const char* input = buffer->data; - const char* const eof = input + buffer->size; - - msgpack_unpacker pac; - msgpack_unpacker_init(&pac, MSGPACK_UNPACKER_INIT_BUFFER_SIZE); - - msgpack_unpacked result; - msgpack_unpacked_init(&result); - - int count = 0; - while(count < max_count) { - bool unpacked = false; - - msgpack_unpacker_reserve_buffer(&pac, 32*1024); - - while(!unpacked) { - /* read buffer into msgpack_unapcker_buffer(&pac) upto - * msgpack_unpacker_buffer_capacity(&pac) bytes. */ - memcpy(msgpack_unpacker_buffer(&pac), input, 1); - input += 1; - - EXPECT_TRUE(input <= eof); - - msgpack_unpacker_buffer_consumed(&pac, 1); - - while(msgpack_unpacker_next(&pac, &result) == MSGPACK_UNPACK_SUCCESS) { - unpacked = 1; - msgpack_object obj = result.data; - msgpack_object e; - switch(count++) { - case 0: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(1, obj.via.u64); - break; - case 1: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(2, obj.via.u64); - break; - case 2: - EXPECT_EQ(MSGPACK_OBJECT_POSITIVE_INTEGER, obj.type); - EXPECT_EQ(3, obj.via.u64); - break; - case 3: - EXPECT_EQ(MSGPACK_OBJECT_STR, obj.type); - EXPECT_EQ(std::string("str",3), std::string(obj.via.str.ptr, obj.via.str.size)); - break; - case 4: - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1, obj.via.array.size); - e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_STR, e.type); - EXPECT_EQ(std::string("str_data",8), std::string(e.via.str.ptr, e.via.str.size)); - break; - case 5: - EXPECT_EQ(MSGPACK_OBJECT_BIN, obj.type); - EXPECT_EQ(std::string("bin",3), std::string(obj.via.bin.ptr, obj.via.bin.size)); - break; - case 6: - EXPECT_EQ(MSGPACK_OBJECT_ARRAY, obj.type); - EXPECT_EQ(1, obj.via.array.size); - e = obj.via.array.ptr[0]; - EXPECT_EQ(MSGPACK_OBJECT_BIN, e.type); - EXPECT_EQ(std::string("bin_data",8), std::string(e.via.bin.ptr, e.via.bin.size)); - break; - case 7: - EXPECT_EQ(MSGPACK_OBJECT_MAP, obj.type); - EXPECT_EQ(1, obj.via.map.size); - e = obj.via.map.ptr[0].key; - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_FLOAT_EQ(0.4, (float)e.via.dec); - e = obj.via.map.ptr[0].val; - EXPECT_EQ(MSGPACK_OBJECT_DOUBLE, e.type); - ASSERT_DOUBLE_EQ(0.8, e.via.dec); - break; - } - } - } - } - - msgpack_unpacker_destroy(&pac); - msgpack_unpacked_destroy(&result); -} - diff --git a/test/version.cc b/test/version.cc deleted file mode 100644 index d2809b21..00000000 --- a/test/version.cc +++ /dev/null @@ -1,13 +0,0 @@ -#include -#include - -TEST(version, print) -{ - printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); - printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); - printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); - printf("msgpack_version() : %s\n", msgpack_version()); - printf("msgpack_version_major() : %d\n", msgpack_version_major()); - printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); -} - diff --git a/test/zone.cc b/test/zone.cc deleted file mode 100644 index b2dc543e..00000000 --- a/test/zone.cc +++ /dev/null @@ -1,78 +0,0 @@ -#include -#include - -TEST(zone, allocate_align) -{ - msgpack::zone z; - char* buf1 = (char*)z.allocate_align(4); - memcpy(buf1, "test", 4); - char* buf2 = (char*)z.allocate_align(4); - memcpy(buf2, "test", 4); -} - - -class myclass { -public: - myclass() : num(0), str("default") { } - - myclass(int num, const std::string& str) : - num(num), str(str) { } - - ~myclass() { } - - int num; - std::string str; - -private: - myclass(const myclass&); -}; - - -TEST(zone, allocate) -{ - msgpack::zone z; - myclass* m = z.allocate(); - EXPECT_EQ(m->num, 0); - EXPECT_EQ(m->str, "default"); -} - - -TEST(zone, allocate_constructor) -{ - msgpack::zone z; - myclass* m = z.allocate(7, "msgpack"); - EXPECT_EQ(m->num, 7); - EXPECT_EQ(m->str, "msgpack"); -} - - -static void custom_finalizer_func(void* user) -{ - myclass* m = (myclass*)user; - delete m; -} - -TEST(zone, push_finalizer) -{ - msgpack::zone z; - myclass* m = new myclass(); - z.push_finalizer(custom_finalizer_func, (void*)m); -} - - -TEST(zone, push_finalizer_unique_ptr) -{ - msgpack::zone z; - msgpack::unique_ptr am(new myclass()); - z.push_finalizer(msgpack::move(am)); -} - - -TEST(zone, allocate_no_align) -{ - msgpack::zone z; - char* buf1 = (char*)z.allocate_no_align(4); - char* buf2 = (char*)z.allocate_no_align(4); - EXPECT_EQ(buf1+4, buf2); -} - From 4d6e9d6c056146d54faf6168ca415acfd56a6692 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 11 Aug 2014 15:50:51 +0900 Subject: [PATCH 116/153] Removed referenced member from msgpack::unpacked. Added a referenced parameter to msgpack::unpack() and msgpack::unpacker::next(). msgpack::unpacked is a kind of handler that holds msgpack::object and msgpack::zone, so the size of msgpack::unpacked should be small. There is no reason to have referenced in msgpack::unpacked. msgpack user can get the same information using msgpack::unpack() and msgpack::unpacker::next(). --- include/msgpack/unpack.hpp | 66 ++++++++++++------ test/msgpack_test.cpp | 38 ----------- test/msgpack_test_cpp11.cpp | 4 -- test/reference.cpp | 131 ++++++++++++++++++++++-------------- 4 files changed, 125 insertions(+), 114 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 60df2f6d..652bbcbd 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -820,7 +820,7 @@ struct unpack_error : public std::runtime_error { class unpacked { public: - unpacked():m_referenced(false) { } + unpacked() {} unpacked(object const& obj, msgpack::unique_ptr z) : m_obj(obj), m_zone(msgpack::move(z)) { } @@ -837,12 +837,6 @@ public: const msgpack::unique_ptr& zone() const { return m_zone; } - void set_referenced(bool r) - { m_referenced = r; } - - bool referenced() const - { return m_referenced; } - private: object m_obj; msgpack::unique_ptr m_zone; @@ -876,6 +870,7 @@ public: /*! 4. repeat next() until it retunrs false */ bool next(unpacked* result); + bool next(unpacked& result, bool& referenced); bool next(unpacked& result); /*! 5. check if the size of message doesn't exceed assumption. */ @@ -970,16 +965,22 @@ private: unpacker& operator=(const unpacker&); }; +inline void unpack(unpacked& result, + const char* data, std::size_t len, std::size_t& off, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); inline void unpack(unpacked& result, const char* data, std::size_t len, std::size_t& off, unpack_reference_func f = nullptr, void* user_data = nullptr); +inline void unpack(unpacked& result, + const char* data, std::size_t len, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); inline void unpack(unpacked& result, const char* data, std::size_t len, unpack_reference_func f = nullptr, void* user_data = nullptr); // obsolete inline void unpack(unpacked* result, - const char* data, std::size_t len, std::size_t* off = nullptr, + const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr, unpack_reference_func f = nullptr, void* user_data = nullptr); @@ -1134,10 +1135,10 @@ inline void unpacker::buffer_consumed(std::size_t size) m_free -= size; } -inline bool unpacker::next(unpacked& result) +inline bool unpacker::next(unpacked& result, bool& referenced) { + referenced = false; int ret = execute_imp(); - if(ret < 0) { throw unpack_error("parse error"); } @@ -1148,7 +1149,7 @@ inline bool unpacker::next(unpacked& result) return false; } else { - result.set_referenced(m_ctx.user().referenced()); + referenced = m_ctx.user().referenced(); result.zone().reset( release_zone() ); result.set(data()); reset(); @@ -1156,6 +1157,12 @@ inline bool unpacker::next(unpacked& result) } } +inline bool unpacker::next(unpacked& result) +{ + bool referenced; + return next(result, referenced); +} + inline bool unpacker::next(unpacked* result) { return next(*result); @@ -1307,17 +1314,15 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off, // reference version inline void unpack(unpacked& result, - const char* data, std::size_t len, std::size_t& off, + const char* data, std::size_t len, std::size_t& off, bool& referenced, unpack_reference_func f, void* user_data) { object obj; msgpack::unique_ptr z(new zone); - bool referenced = false; + referenced = false; unpack_return ret = detail::unpack_imp( data, len, off, *z, obj, referenced, f, user_data); - result.set_referenced(referenced); - switch(ret) { case UNPACK_SUCCESS: result.set(obj); @@ -1336,21 +1341,42 @@ inline void unpack(unpacked& result, } inline void unpack(unpacked& result, - const char* data, std::size_t len, + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f, void* user_data) +{ + bool referenced; + unpack(result, data, len, off, referenced, f, user_data); +} + +inline void unpack(unpacked& result, + const char* data, std::size_t len, bool& referenced, unpack_reference_func f, void* user_data) { std::size_t off = 0; - unpack(result, data, len, off, f, user_data); + unpack(result, data, len, off, referenced, f, user_data); +} + +inline void unpack(unpacked& result, + const char* data, std::size_t len, + unpack_reference_func f, void* user_data) +{ + bool referenced; + std::size_t off = 0; + unpack(result, data, len, off, referenced, f, user_data); } // obsolete // pointer version inline void unpack(unpacked* result, - const char* data, std::size_t len, std::size_t* off, + const char* data, std::size_t len, std::size_t* off, bool* referenced, unpack_reference_func f, void* user_data) { - if (off) unpack(*result, data, len, *off); - else unpack(*result, data, len, f, user_data); + if (off) + if (referenced) unpack(*result, data, len, *off, *referenced, f, user_data); + else unpack(*result, data, len, *off, f, user_data); + else + if (referenced) unpack(*result, data, len, *referenced, f, user_data); + else unpack(*result, data, len, f, user_data); } bool unpacker::default_reference_func(type::object_type type, uint64_t len, void*) diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index f47aeeee..bef5f93a 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -38,7 +38,6 @@ const double kEPS = 1e-10; msgpack::unpacked ret; \ msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ EXPECT_EQ(val1, ret.get().as()); \ - EXPECT_FALSE(ret.referenced()); \ } \ } while(0) @@ -206,7 +205,6 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) msgpack::unpack(ret, sbuf.data(), sbuf.size()); float_type val2 = ret.get().as(); EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - EXPECT_FALSE(ret.referenced()); } } @@ -244,7 +242,6 @@ TEST(MSGPACK, simple_buffer_double) msgpack::unpacked ret; msgpack::unpack(ret, sbuf.data(), sbuf.size()); double val2 = ret.get().as(); - EXPECT_FALSE(ret.referenced()); if (std::isnan(val1)) EXPECT_TRUE(std::isnan(val2)); @@ -264,7 +261,6 @@ TEST(MSGPACK, simple_buffer_true) msgpack::unpack(ret, sbuf.data(), sbuf.size()); bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_false) @@ -276,7 +272,6 @@ TEST(MSGPACK, simple_buffer_false) msgpack::unpack(ret, sbuf.data(), sbuf.size()); bool val2 = ret.get().as(); EXPECT_EQ(val1, val2); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext1) @@ -292,7 +287,6 @@ TEST(MSGPACK, simple_buffer_fixext1) EXPECT_EQ(1, ret.get().via.ext.size); EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_EQ(2, ret.get().via.ext.data()[0]); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext2) @@ -309,7 +303,6 @@ TEST(MSGPACK, simple_buffer_fixext2) EXPECT_EQ(0, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext4) @@ -326,7 +319,6 @@ TEST(MSGPACK, simple_buffer_fixext4) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext8) @@ -343,7 +335,6 @@ TEST(MSGPACK, simple_buffer_fixext8) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext16) @@ -360,7 +351,6 @@ TEST(MSGPACK, simple_buffer_fixext16) EXPECT_EQ(1, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_1byte_0) @@ -374,7 +364,6 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_0) msgpack::unpack(ret, sbuf.data(), sbuf.size()); EXPECT_EQ(size, ret.get().via.ext.size); EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_1byte_255) @@ -393,7 +382,6 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_2byte_256) @@ -412,7 +400,6 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_2byte_65535) @@ -431,7 +418,6 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK, simple_buffer_fixext_4byte_65536) @@ -450,7 +436,6 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536) EXPECT_EQ(77, ret.get().via.ext.type()); EXPECT_TRUE( std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); - EXPECT_FALSE(ret.referenced()); } //----------------------------------------------------------------------------- @@ -471,7 +456,6 @@ TEST(MSGPACK_STL, simple_buffer_string) string val2 = ret.get().as(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_EQ(val1, val2); - EXPECT_FALSE(ret.referenced()); } } @@ -489,7 +473,6 @@ TEST(MSGPACK_STL, simple_buffer_vector) vector val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - EXPECT_FALSE(ret.referenced()); } } @@ -523,7 +506,6 @@ TEST(MSGPACK_STL, simple_buffer_map) map val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - EXPECT_FALSE(ret.referenced()); } } @@ -540,7 +522,6 @@ TEST(MSGPACK_STL, simple_buffer_deque) deque val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - EXPECT_FALSE(ret.referenced()); } } @@ -557,7 +538,6 @@ TEST(MSGPACK_STL, simple_buffer_list) list val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - EXPECT_FALSE(ret.referenced()); } } @@ -574,7 +554,6 @@ TEST(MSGPACK_STL, simple_buffer_set) set val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - EXPECT_FALSE(ret.referenced()); } } @@ -589,7 +568,6 @@ TEST(MSGPACK_STL, simple_buffer_pair) pair val2 = ret.get().as >(); EXPECT_EQ(val1.first, val2.first); EXPECT_EQ(val1.second, val2.second); - EXPECT_FALSE(ret.referenced()); } } @@ -619,7 +597,6 @@ TEST(MSGPACK_STL, simple_buffer_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); - EXPECT_FALSE(ret.referenced()); } } @@ -646,7 +623,6 @@ TEST(MSGPACK_STL, simple_buffer_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); - EXPECT_FALSE(ret.referenced()); } } @@ -672,7 +648,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) EXPECT_TRUE(val2.find(it->first) != val2.end()); EXPECT_EQ(it->second, val2.find(it->first)->second); } - EXPECT_FALSE(ret.referenced()); } } @@ -702,7 +677,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); - EXPECT_FALSE(ret.referenced()); } } #endif @@ -725,7 +699,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) tr1::unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) EXPECT_TRUE(val2.find(*it) != val2.end()); - EXPECT_FALSE(ret.referenced()); } } @@ -752,7 +725,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); - EXPECT_FALSE(ret.referenced()); } } #endif @@ -777,7 +749,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map) EXPECT_TRUE(val2.find(it->first) != val2.end()); EXPECT_EQ(it->second, val2.find(it->first)->second); } - EXPECT_FALSE(ret.referenced()); } } @@ -807,7 +778,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); - EXPECT_FALSE(ret.referenced()); } } #endif @@ -830,7 +800,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set) unordered_set::const_iterator it; for (it = val1.begin(); it != val1.end(); ++it) EXPECT_TRUE(val2.find(*it) != val2.end()); - EXPECT_FALSE(ret.referenced()); } } @@ -857,7 +826,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); EXPECT_TRUE(v1 == v2); - EXPECT_FALSE(ret.referenced()); } } #endif @@ -885,7 +853,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class) TestClass val2 = ret.get().as(); EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); - EXPECT_FALSE(ret.referenced()); } } @@ -914,7 +881,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) EXPECT_EQ(val1.i, val2.i); EXPECT_EQ(val1.s, val2.s); EXPECT_FALSE(val2.s.empty()); - EXPECT_FALSE(ret.referenced()); } } @@ -965,7 +931,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); - EXPECT_FALSE(ret.referenced()); } class TestUnionMemberClass @@ -1021,7 +986,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) TestUnionMemberClass val2 = ret.get().as(); EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); - EXPECT_FALSE(ret.referenced()); } { // int @@ -1034,7 +998,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) EXPECT_EQ(val1.is_double, val2.is_double); EXPECT_EQ(val1.value.i, 1); EXPECT_EQ(val1.value.i, val2.value.i); - EXPECT_FALSE(ret.referenced()); } } @@ -1056,7 +1019,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ test_type val2 = ret.get().as(); \ EXPECT_EQ(val1, val2); \ - EXPECT_FALSE(ret.referenced()); \ } \ } while(0); diff --git a/test/msgpack_test_cpp11.cpp b/test/msgpack_test_cpp11.cpp index 0d13123b..d06b184c 100644 --- a/test/msgpack_test_cpp11.cpp +++ b/test/msgpack_test_cpp11.cpp @@ -25,7 +25,6 @@ TEST(MSGPACK_CPP11, simple_tuple) msgpack::unpack(ret, sbuf.data(), sbuf.size()); std::tuple val2 = ret.get().as >(); EXPECT_EQ(val1, val2); - EXPECT_FALSE(ret.referenced()); } TEST(MSGPACK_CPP11, simple_array) @@ -42,7 +41,6 @@ TEST(MSGPACK_CPP11, simple_array) array val2 = ret.get().as >(); EXPECT_EQ(val1.size(), val2.size()); EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - EXPECT_FALSE(ret.referenced()); } } @@ -75,7 +73,6 @@ TEST(MSGPACK_STL, simple_buffer_forward_list) msgpack::unpack(ret, sbuf.data(), sbuf.size()); forward_list val2 = ret.get().as >(); EXPECT_EQ(val1, val2); - EXPECT_FALSE(ret.referenced()); } } @@ -112,7 +109,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member) EXPECT_EQ(val1.t1, val2.t1); EXPECT_EQ(val1.t2, val2.t2); EXPECT_EQ(val1.t3, val2.t3); - EXPECT_FALSE(ret.referenced()); } #endif // !defined(MSGPACK_USE_CPP03) diff --git a/test/reference.cpp b/test/reference.cpp index 09ecbca5..7c338a38 100644 --- a/test/reference.cpp +++ b/test/reference.cpp @@ -6,9 +6,10 @@ TEST(reference, unpack_int) msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); msgpack::unpacked ret; + bool referenced; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); } TEST(reference, unpack_string) @@ -16,9 +17,10 @@ TEST(reference, unpack_string) msgpack::sbuffer sbuf; msgpack::pack(sbuf, std::string("abcdefg")); msgpack::unpacked ret; + bool referenced; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); } TEST(reference, unpack_bin) @@ -30,8 +32,9 @@ TEST(reference, unpack_bin) packer.pack_bin_body(c, sizeof(c)); msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); } TEST(reference, unpack_ext) @@ -43,8 +46,9 @@ TEST(reference, unpack_ext) packer.pack_ext(sizeof(buf), 1); packer.pack_ext_body(buf, sizeof(buf)); msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_FALSE(ret.referenced()); + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); } bool never_called(msgpack::type::object_type, std::size_t, void*) @@ -63,9 +67,10 @@ TEST(reference, unpack_int_ref) msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); msgpack::unpacked ret; + bool referenced; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called); - EXPECT_FALSE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called); + EXPECT_FALSE(referenced); } TEST(reference, unpack_string_ref) @@ -73,9 +78,11 @@ TEST(reference, unpack_string_ref) msgpack::sbuffer sbuf; msgpack::pack(sbuf, std::string("abcdefg")); msgpack::unpacked ret; + bool referenced; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); - EXPECT_TRUE(ret.referenced()); + + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); } TEST(reference, unpack_bin_ref) @@ -87,8 +94,9 @@ TEST(reference, unpack_bin_ref) packer.pack_bin_body(c, sizeof(c)); msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); - EXPECT_TRUE(ret.referenced()); + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); } TEST(reference, unpack_ext_ref) @@ -100,8 +108,9 @@ TEST(reference, unpack_ext_ref) packer.pack_ext(sizeof(buf), 1); packer.pack_ext_body(buf, sizeof(buf)); msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference); - EXPECT_TRUE(ret.referenced()); + bool referenced; + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); } static void* s_p; @@ -131,9 +140,10 @@ TEST(reference, unpack_int_sized_ref) msgpack::pack(sbuf, 1); msgpack::unpacked ret; + bool referenced; s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf); - EXPECT_FALSE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called, &sbuf); + EXPECT_FALSE(referenced); EXPECT_EQ(nullptr, s_p); } @@ -143,11 +153,12 @@ TEST(reference, unpack_string_sized_ref_4) msgpack::pack(sbuf, std::string("1234")); msgpack::unpacked ret; + bool referenced; s_p = nullptr; // the last argument sbuf is any pointer as a user data. // That is stored to s_p in sized_reference - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_FALSE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); // compare the passed argument with stored s_p. EXPECT_EQ(&sbuf, s_p); } @@ -158,9 +169,10 @@ TEST(reference, unpack_string_sized_ref_5) msgpack::pack(sbuf, std::string("12345")); msgpack::unpacked ret; + bool referenced; s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_TRUE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -174,9 +186,10 @@ TEST(reference, unpack_bin_sized_ref_5) packer.pack_bin_body(c, sizeof(c)); msgpack::unpacked ret; + bool referenced; s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_FALSE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -189,9 +202,10 @@ TEST(reference, unpack_bin_sized_ref_6) packer.pack_bin_body(c, sizeof(c)); msgpack::unpacked ret; + bool referenced; s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_TRUE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -205,9 +219,10 @@ TEST(reference, unpack_ext_sized_ref_6) packer.pack_ext_body(buf, sizeof(buf)); msgpack::unpacked ret; + bool referenced; s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_FALSE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -221,9 +236,10 @@ TEST(reference, unpack_ext_sized_ref_7) packer.pack_ext_body(buf, sizeof(buf)); msgpack::unpacked ret; + bool referenced; s_p = nullptr; - msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf); - EXPECT_TRUE(ret.referenced()); + msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -237,12 +253,13 @@ TEST(reference, unpacker_int) msgpack::unpacker unp; msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); + EXPECT_FALSE(referenced); } TEST(reference, unpacker_string) @@ -252,12 +269,13 @@ TEST(reference, unpacker_string) msgpack::unpacker unp; msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); + EXPECT_TRUE(referenced); } TEST(reference, unpacker_bin) @@ -270,12 +288,13 @@ TEST(reference, unpacker_bin) msgpack::unpacker unp; msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); + EXPECT_TRUE(referenced); } TEST(reference, unpacker_ext) @@ -289,12 +308,13 @@ TEST(reference, unpacker_ext) msgpack::unpacker unp; msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); + EXPECT_TRUE(referenced); } // pass user custom reference function @@ -306,13 +326,14 @@ TEST(reference, unpacker_int_sized_ref) msgpack::unpacker unp(never_called, &sbuf); msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); s_p = nullptr; - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); + EXPECT_FALSE(referenced); EXPECT_EQ(nullptr, s_p); } @@ -323,13 +344,14 @@ TEST(reference, unpacker_string_sized_ref_4) msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); s_p = nullptr; - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); + EXPECT_FALSE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -340,13 +362,14 @@ TEST(reference, unpacker_string_sized_ref_5) msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); s_p = nullptr; - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); + EXPECT_TRUE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -361,13 +384,14 @@ TEST(reference, unpacker_bin_sized_ref_5) msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); s_p = nullptr; - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); + EXPECT_FALSE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -381,13 +405,14 @@ TEST(reference, unpacker_bin_sized_ref_6) msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); s_p = nullptr; - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); + EXPECT_TRUE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -402,13 +427,14 @@ TEST(reference, unpacker_ext_sized_ref_6) msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); s_p = nullptr; - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_FALSE(ret.referenced()); + EXPECT_FALSE(referenced); EXPECT_EQ(&sbuf, s_p); } @@ -423,12 +449,13 @@ TEST(reference, unpacker_ext_sized_ref_7) msgpack::unpacker unp(sized_reference, &sbuf); msgpack::unpacked ret; + bool referenced; unp.reserve_buffer(sbuf.size()); std::memcpy(unp.buffer(), sbuf.data(), sbuf.size()); unp.buffer_consumed(sbuf.size()); s_p = nullptr; - bool b = unp.next(ret); + bool b = unp.next(ret, referenced); EXPECT_TRUE(b); - EXPECT_TRUE(ret.referenced()); + EXPECT_TRUE(referenced); EXPECT_EQ(&sbuf, s_p); } From 2c2df64427e2014a1f49e5fcf4d6110c338a4cbe Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 29 Aug 2014 00:38:44 +0900 Subject: [PATCH 117/153] Fixed C++03 and C++11 conditional tests building problem on cmake. --- test/CMakeLists.txt | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index ce1aea91..eed53ec6 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -7,7 +7,7 @@ INCLUDE_DIRECTORIES ( ${ZLIB_INCLUDE_DIRS} ) -SET (check_PROGRAMS +LIST (APPEND check_PROGRAMS zone.cpp pack_unpack.cpp pack_unpack_c.cpp @@ -24,10 +24,15 @@ SET (check_PROGRAMS msgpack_tuple.cpp msgpack_test.cpp msgpackc_test.cpp - msgpack_test_cpp11.cpp reference.cpp ) +IF (MSGPACK_CXX11) + LIST (APPEND check_PROGRAMS + msgpack_test_cpp11.cpp + ) +ENDIF () + FOREACH (source_file ${check_PROGRAMS}) GET_FILENAME_COMPONENT (source_file_we ${source_file} NAME_WE) ADD_EXECUTABLE ( From 68bf4acb4b40fe6973812a74073acd6dae4afa9c Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Fri, 29 Aug 2014 00:43:18 +0900 Subject: [PATCH 118/153] Fixed operator>>(object const& o, various types& v) return type and value problem. https://github.com/msgpack/msgpack-c/issues/105 --- erb/cpp03_define.hpp.erb | 5 +- erb/cpp03_msgpack_tuple.hpp.erb | 8 +- include/msgpack/adaptor/bool.hpp | 5 +- include/msgpack/adaptor/cpp11/array.hpp | 4 +- include/msgpack/adaptor/cpp11/array_char.hpp | 4 +- .../msgpack/adaptor/cpp11/forward_list.hpp | 4 +- include/msgpack/adaptor/cpp11/tuple.hpp | 5 +- include/msgpack/adaptor/deque.hpp | 5 +- .../msgpack/adaptor/detail/cpp03_define.hpp | 5 +- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 132 +++++++++--------- .../msgpack/adaptor/detail/cpp11_define.hpp | 4 +- .../adaptor/detail/cpp11_msgpack_tuple.hpp | 5 +- include/msgpack/adaptor/fixint.hpp | 33 +++-- include/msgpack/adaptor/float.hpp | 9 +- include/msgpack/adaptor/int.hpp | 45 +++--- include/msgpack/adaptor/list.hpp | 5 +- include/msgpack/adaptor/map.hpp | 12 +- include/msgpack/adaptor/nil.hpp | 5 +- include/msgpack/adaptor/pair.hpp | 5 +- include/msgpack/adaptor/raw.hpp | 5 +- include/msgpack/adaptor/set.hpp | 9 +- include/msgpack/adaptor/string.hpp | 5 +- include/msgpack/adaptor/tr1/unordered_map.hpp | 8 +- include/msgpack/adaptor/tr1/unordered_set.hpp | 9 +- include/msgpack/adaptor/vector.hpp | 5 +- include/msgpack/adaptor/vector_char.hpp | 5 +- include/msgpack/object.hpp | 8 +- 27 files changed, 168 insertions(+), 186 deletions(-) diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index 10ef4502..04c6a0fe 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -38,12 +38,12 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object const& o, enum& v) \ + inline object const& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ v = static_cast(tmp); \ - return v; \ + return o; \ } \ template <> \ inline void operator<< (object::with_zone& o, const enum& v) \ @@ -145,4 +145,3 @@ define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, #endif // MSGPACK_CPP03_DEFINE_HPP - diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index 5fa95fcc..f748ccfd 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -133,22 +133,22 @@ tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::tr } // namespace type -inline type::tuple<>& operator>> ( +inline object const& operator>> ( object const& o, type::tuple<>& v) { if(o.type != type::ARRAY) { throw type_error(); } - return v; + return o; } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> -type::tuple, A<%=j%><%}%>>& operator>> ( +object const& operator>> ( object const& o, type::tuple, A<%=j%><%}%>>& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < <%=i+1%>) { throw type_error(); } <%0.upto(i) {|j|%> o.via.array.ptr[<%=j%>].convert>::type>(v.template get<<%=j%>>());<%}%> - return v; + return o; } <%}%> diff --git a/include/msgpack/adaptor/bool.hpp b/include/msgpack/adaptor/bool.hpp index e027ad51..bdfb2408 100644 --- a/include/msgpack/adaptor/bool.hpp +++ b/include/msgpack/adaptor/bool.hpp @@ -24,11 +24,11 @@ namespace msgpack { -inline bool& operator>> (object const& o, bool& v) +inline object const& operator>> (object const& o, bool& v) { if(o.type != type::BOOLEAN) { throw type_error(); } v = o.via.boolean; - return v; + return o; } template @@ -52,4 +52,3 @@ inline void operator<< (object::with_zone& o, bool v) } // namespace msgpack #endif /* msgpack/type/bool.hpp */ - diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp index be89559b..5c1cb3b0 100644 --- a/include/msgpack/adaptor/cpp11/array.hpp +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -27,7 +27,7 @@ namespace msgpack { template -inline std::array& operator>> (object const& o, std::array& v) { +inline object const& operator>> (object const& o, std::array& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size != N) { throw type_error(); } if(o.via.array.size > 0) { @@ -40,7 +40,7 @@ inline std::array& operator>> (object const& o, std::array& v) { ++it; } while(p < pend); } - return v; + return o; } template diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp index 71f1e87d..a7cfcc2f 100644 --- a/include/msgpack/adaptor/cpp11/array_char.hpp +++ b/include/msgpack/adaptor/cpp11/array_char.hpp @@ -24,7 +24,7 @@ namespace msgpack { template -inline std::array& operator>> (object const& o, std::array& v) +inline object const& operator>> (object const& o, std::array& v) { switch (o.type) { case type::BIN: @@ -39,7 +39,7 @@ inline std::array& operator>> (object const& o, std::array& v) throw type_error(); break; } - return v; + return o; } template diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index 272a7ef3..68e5ac22 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -27,7 +27,7 @@ namespace msgpack { template -inline std::forward_list& operator>> (object const& o, std::forward_list& v) +inline object const& operator>> (object const& o, std::forward_list& v) { if(o.type != type::ARRAY) { throw type_error(); } v.resize(o.via.array.size); @@ -36,7 +36,7 @@ inline std::forward_list& operator>> (object const& o, std::forward_list& p->convert(e); ++p; } - return v; + return o; } template diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index 79298d6e..e29a0e17 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -76,13 +76,13 @@ struct StdTupleConverter { }; template -std::tuple& operator>> ( +object const& operator>> ( object const& o, std::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); } StdTupleConverter::convert(o, v); - return v; + return o; } // --- Convert from tuple to object with zone --- @@ -118,4 +118,3 @@ inline void operator<< ( } // msgpack #endif // MSGPACK_CPP11_TUPLE_HPP - diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index c6571343..f5609c88 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::deque& operator>> (object const& o, std::deque& v) +inline object const& operator>> (object const& o, std::deque& v) { if(o.type != type::ARRAY) { throw type_error(); } v.resize(o.via.array.size); @@ -35,7 +35,7 @@ inline std::deque& operator>> (object const& o, std::deque& v) for(; p < pend; ++p, ++it) { p->convert(*it); } - return v; + return o; } template @@ -74,4 +74,3 @@ inline void operator<< (object::with_zone& o, const std::deque& v) } // namespace msgpack #endif /* msgpack/type/deque.hpp */ - diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index 30090d3e..675690c2 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -38,12 +38,12 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object const& o, enum& v) \ + inline object const& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ v = static_cast(tmp); \ - return v; \ + return o; \ } \ template <> \ inline void operator<< (object::with_zone& o, const enum& v) \ @@ -3462,4 +3462,3 @@ define& operator>> ( +inline object const& operator>> ( object const& o, type::tuple<>& v) { if(o.type != type::ARRAY) { throw type_error(); } - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < 1) { throw type_error(); } o.via.array.ptr[0].convert::type>(v.template get<0>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10607,11 +10607,11 @@ type::tuple& operator>> ( o.via.array.ptr[0].convert::type>(v.template get<0>()); o.via.array.ptr[1].convert::type>(v.template get<1>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10620,11 +10620,11 @@ type::tuple& operator>> ( o.via.array.ptr[0].convert::type>(v.template get<0>()); o.via.array.ptr[1].convert::type>(v.template get<1>()); o.via.array.ptr[2].convert::type>(v.template get<2>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10634,11 +10634,11 @@ type::tuple& operator>> ( o.via.array.ptr[1].convert::type>(v.template get<1>()); o.via.array.ptr[2].convert::type>(v.template get<2>()); o.via.array.ptr[3].convert::type>(v.template get<3>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10649,11 +10649,11 @@ type::tuple& operator>> ( o.via.array.ptr[2].convert::type>(v.template get<2>()); o.via.array.ptr[3].convert::type>(v.template get<3>()); o.via.array.ptr[4].convert::type>(v.template get<4>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10665,11 +10665,11 @@ type::tuple& operator>> ( o.via.array.ptr[3].convert::type>(v.template get<3>()); o.via.array.ptr[4].convert::type>(v.template get<4>()); o.via.array.ptr[5].convert::type>(v.template get<5>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10682,11 +10682,11 @@ type::tuple& operator>> ( o.via.array.ptr[4].convert::type>(v.template get<4>()); o.via.array.ptr[5].convert::type>(v.template get<5>()); o.via.array.ptr[6].convert::type>(v.template get<6>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10700,11 +10700,11 @@ type::tuple& operator>> ( o.via.array.ptr[5].convert::type>(v.template get<5>()); o.via.array.ptr[6].convert::type>(v.template get<6>()); o.via.array.ptr[7].convert::type>(v.template get<7>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10719,11 +10719,11 @@ type::tuple& operator>> ( o.via.array.ptr[6].convert::type>(v.template get<6>()); o.via.array.ptr[7].convert::type>(v.template get<7>()); o.via.array.ptr[8].convert::type>(v.template get<8>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10739,11 +10739,11 @@ type::tuple& operator>> ( o.via.array.ptr[7].convert::type>(v.template get<7>()); o.via.array.ptr[8].convert::type>(v.template get<8>()); o.via.array.ptr[9].convert::type>(v.template get<9>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10760,11 +10760,11 @@ type::tuple& operator>> ( o.via.array.ptr[8].convert::type>(v.template get<8>()); o.via.array.ptr[9].convert::type>(v.template get<9>()); o.via.array.ptr[10].convert::type>(v.template get<10>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10782,11 +10782,11 @@ type::tuple& operator>> ( o.via.array.ptr[9].convert::type>(v.template get<9>()); o.via.array.ptr[10].convert::type>(v.template get<10>()); o.via.array.ptr[11].convert::type>(v.template get<11>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10805,11 +10805,11 @@ type::tuple& operator>> ( o.via.array.ptr[10].convert::type>(v.template get<10>()); o.via.array.ptr[11].convert::type>(v.template get<11>()); o.via.array.ptr[12].convert::type>(v.template get<12>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10829,11 +10829,11 @@ type::tuple& operato o.via.array.ptr[11].convert::type>(v.template get<11>()); o.via.array.ptr[12].convert::type>(v.template get<12>()); o.via.array.ptr[13].convert::type>(v.template get<13>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10854,11 +10854,11 @@ type::tuple& op o.via.array.ptr[12].convert::type>(v.template get<12>()); o.via.array.ptr[13].convert::type>(v.template get<13>()); o.via.array.ptr[14].convert::type>(v.template get<14>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10880,11 +10880,11 @@ type::tuple::type>(v.template get<13>()); o.via.array.ptr[14].convert::type>(v.template get<14>()); o.via.array.ptr[15].convert::type>(v.template get<15>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10907,11 +10907,11 @@ type::tuple::type>(v.template get<14>()); o.via.array.ptr[15].convert::type>(v.template get<15>()); o.via.array.ptr[16].convert::type>(v.template get<16>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10935,11 +10935,11 @@ type::tuple::type>(v.template get<15>()); o.via.array.ptr[16].convert::type>(v.template get<16>()); o.via.array.ptr[17].convert::type>(v.template get<17>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10964,11 +10964,11 @@ type::tuple::type>(v.template get<16>()); o.via.array.ptr[17].convert::type>(v.template get<17>()); o.via.array.ptr[18].convert::type>(v.template get<18>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10994,11 +10994,11 @@ type::tuple::type>(v.template get<17>()); o.via.array.ptr[18].convert::type>(v.template get<18>()); o.via.array.ptr[19].convert::type>(v.template get<19>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11025,11 +11025,11 @@ type::tuple::type>(v.template get<18>()); o.via.array.ptr[19].convert::type>(v.template get<19>()); o.via.array.ptr[20].convert::type>(v.template get<20>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11057,11 +11057,11 @@ type::tuple::type>(v.template get<19>()); o.via.array.ptr[20].convert::type>(v.template get<20>()); o.via.array.ptr[21].convert::type>(v.template get<21>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11090,11 +11090,11 @@ type::tuple::type>(v.template get<20>()); o.via.array.ptr[21].convert::type>(v.template get<21>()); o.via.array.ptr[22].convert::type>(v.template get<22>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11124,11 +11124,11 @@ type::tuple::type>(v.template get<21>()); o.via.array.ptr[22].convert::type>(v.template get<22>()); o.via.array.ptr[23].convert::type>(v.template get<23>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11159,11 +11159,11 @@ type::tuple::type>(v.template get<22>()); o.via.array.ptr[23].convert::type>(v.template get<23>()); o.via.array.ptr[24].convert::type>(v.template get<24>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11195,11 +11195,11 @@ type::tuple::type>(v.template get<23>()); o.via.array.ptr[24].convert::type>(v.template get<24>()); o.via.array.ptr[25].convert::type>(v.template get<25>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11232,11 +11232,11 @@ type::tuple::type>(v.template get<24>()); o.via.array.ptr[25].convert::type>(v.template get<25>()); o.via.array.ptr[26].convert::type>(v.template get<26>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11270,11 +11270,11 @@ type::tuple::type>(v.template get<25>()); o.via.array.ptr[26].convert::type>(v.template get<26>()); o.via.array.ptr[27].convert::type>(v.template get<27>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11309,11 +11309,11 @@ type::tuple::type>(v.template get<26>()); o.via.array.ptr[27].convert::type>(v.template get<27>()); o.via.array.ptr[28].convert::type>(v.template get<28>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11349,11 +11349,11 @@ type::tuple::type>(v.template get<27>()); o.via.array.ptr[28].convert::type>(v.template get<28>()); o.via.array.ptr[29].convert::type>(v.template get<29>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11390,11 +11390,11 @@ type::tuple::type>(v.template get<28>()); o.via.array.ptr[29].convert::type>(v.template get<29>()); o.via.array.ptr[30].convert::type>(v.template get<30>()); - return v; + return o; } template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11432,7 +11432,7 @@ type::tuple::type>(v.template get<29>()); o.via.array.ptr[30].convert::type>(v.template get<30>()); o.via.array.ptr[31].convert::type>(v.template get<31>()); - return v; + return o; } diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index 712b08cf..795a1184 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -40,12 +40,12 @@ #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ template <> \ - inline enum& operator>> (object const& o, enum& v) \ + inline object const& operator>> (object const& o, enum& v) \ { \ int tmp; \ o >> tmp; \ v = static_cast(tmp); \ - return v; \ + return o; \ } \ template <> \ inline void operator<< (object::with_zone& o, const enum& v) \ diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 7335e12e..4dee4602 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -140,13 +140,13 @@ struct MsgpackTupleConverter { }; template -type::tuple& operator>> ( +object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size < sizeof...(Args)) { throw type_error(); } MsgpackTupleConverter::convert(o, v); - return v; + return o; } // --- Convert from tuple to object with zone --- @@ -182,4 +182,3 @@ inline void operator<< ( } // msgpack #endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP - diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp index 6acbc132..3deccd10 100644 --- a/include/msgpack/adaptor/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -54,30 +54,30 @@ typedef fix_int fix_int64; } // namespace type -inline type::fix_int8& operator>> (object const& o, type::fix_int8& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_int8& v) + { v = type::detail::convert_integer(o); return o; } -inline type::fix_int16& operator>> (object const& o, type::fix_int16& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_int16& v) + { v = type::detail::convert_integer(o); return o; } -inline type::fix_int32& operator>> (object const& o, type::fix_int32& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_int32& v) + { v = type::detail::convert_integer(o); return o; } -inline type::fix_int64& operator>> (object const& o, type::fix_int64& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_int64& v) + { v = type::detail::convert_integer(o); return o; } -inline type::fix_uint8& operator>> (object const& o, type::fix_uint8& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_uint8& v) + { v = type::detail::convert_integer(o); return o; } -inline type::fix_uint16& operator>> (object const& o, type::fix_uint16& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_uint16& v) + { v = type::detail::convert_integer(o); return o; } -inline type::fix_uint32& operator>> (object const& o, type::fix_uint32& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_uint32& v) + { v = type::detail::convert_integer(o); return o; } -inline type::fix_uint64& operator>> (object const& o, type::fix_uint64& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, type::fix_uint64& v) + { v = type::detail::convert_integer(o); return o; } template @@ -169,4 +169,3 @@ inline void operator<< (object::with_zone& o, type::fix_uint64 v) } // namespace msgpack #endif /* msgpack/type/fixint.hpp */ - diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp index b49767c4..16470e4b 100644 --- a/include/msgpack/adaptor/float.hpp +++ b/include/msgpack/adaptor/float.hpp @@ -27,7 +27,7 @@ namespace msgpack { // FIXME check overflow, underflow -inline float& operator>> (object const& o, float& v) +inline object const& operator>> (object const& o, float& v) { if(o.type == type::DOUBLE) { v = static_cast(o.via.dec); @@ -41,7 +41,7 @@ inline float& operator>> (object const& o, float& v) else { throw type_error(); } - return v; + return o; } template @@ -52,7 +52,7 @@ inline packer& operator<< (packer& o, const float& v) } -inline double& operator>> (object const& o, double& v) +inline object const& operator>> (object const& o, double& v) { if(o.type == type::DOUBLE) { v = o.via.dec; @@ -66,7 +66,7 @@ inline double& operator>> (object const& o, double& v) else { throw type_error(); } - return v; + return o; } template @@ -99,4 +99,3 @@ inline void operator<< (object::with_zone& o, double v) } // namespace msgpack #endif /* msgpack/type/float.hpp */ - diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp index 27ae7031..726bf7d3 100644 --- a/include/msgpack/adaptor/int.hpp +++ b/include/msgpack/adaptor/int.hpp @@ -117,40 +117,40 @@ namespace detail { } // namespace detail } // namespace type -inline char& operator>> (object const& o, char& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, char& v) + { v = type::detail::convert_integer(o); return o; } -inline signed char& operator>> (object const& o, signed char& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, signed char& v) + { v = type::detail::convert_integer(o); return o; } -inline signed short& operator>> (object const& o, signed short& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, signed short& v) + { v = type::detail::convert_integer(o); return o; } -inline signed int& operator>> (object const& o, signed int& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, signed int& v) + { v = type::detail::convert_integer(o); return o; } -inline signed long& operator>> (object const& o, signed long& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, signed long& v) + { v = type::detail::convert_integer(o); return o; } -inline signed long long& operator>> (object const& o, signed long long& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, signed long long& v) + { v = type::detail::convert_integer(o); return o; } -inline unsigned char& operator>> (object const& o, unsigned char& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, unsigned char& v) + { v = type::detail::convert_integer(o); return o; } -inline unsigned short& operator>> (object const& o, unsigned short& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, unsigned short& v) + { v = type::detail::convert_integer(o); return o; } -inline unsigned int& operator>> (object const& o, unsigned int& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, unsigned int& v) + { v = type::detail::convert_integer(o); return o; } -inline unsigned long& operator>> (object const& o, unsigned long& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, unsigned long& v) + { v = type::detail::convert_integer(o); return o; } -inline unsigned long long& operator>> (object const& o, unsigned long long& v) - { v = type::detail::convert_integer(o); return v; } +inline object const& operator>> (object const& o, unsigned long long& v) + { v = type::detail::convert_integer(o); return o; } template @@ -276,4 +276,3 @@ inline void operator<< (object::with_zone& o, const unsigned long long& v) } // namespace msgpack #endif /* msgpack/type/int.hpp */ - diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index 04633a9d..048eae00 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::list& operator>> (object const& o, std::list& v) +inline object const& operator>> (object const& o, std::list& v) { if(o.type != type::ARRAY) { throw type_error(); } v.resize(o.via.array.size); @@ -35,7 +35,7 @@ inline std::list& operator>> (object const& o, std::list& v) for(; p < pend; ++p, ++it) { p->convert(*it); } - return v; + return o; } template @@ -74,4 +74,3 @@ inline void operator<< (object::with_zone& o, const std::list& v) } // namespace msgpack #endif /* msgpack/type/list.hpp */ - diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index ed2fb059..5cf61762 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -43,7 +43,7 @@ namespace detail { template -inline type::assoc_vector& operator>> (object const& o, type::assoc_vector& v) +inline object const& operator>> (object const& o, type::assoc_vector& v) { if(o.type != type::MAP) { throw type_error(); } v.resize(o.via.map.size); @@ -55,7 +55,7 @@ inline type::assoc_vector& operator>> (object const& o, type::assoc_vector< p->val.convert(it->second); } std::sort(v.begin(), v.end(), type::detail::pair_first_less()); - return v; + return o; } template @@ -94,7 +94,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector& v) template -inline std::map& operator>> (object const& o, std::map& v) +inline object const& operator>> (object const& o, std::map& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -111,7 +111,7 @@ inline std::map& operator>> (object const& o, std::map& v) v.insert(it, std::pair(key, val)); } } - return v; + return o; } template @@ -150,7 +150,7 @@ inline void operator<< (object::with_zone& o, const std::map& v) template -inline std::multimap& operator>> (object const& o, std::multimap& v) +inline object const& operator>> (object const& o, std::multimap& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -161,7 +161,7 @@ inline std::multimap& operator>> (object const& o, std::multimap& v) p->val.convert(value.second); v.insert(value); } - return v; + return o; } template diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp index bef57fc5..9f8a12ea 100644 --- a/include/msgpack/adaptor/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -29,10 +29,10 @@ struct nil { }; } // namespace type -inline type::nil& operator>> (object const& o, type::nil& v) +inline object const& operator>> (object const& o, type::nil& v) { if(o.type != type::NIL) { throw type_error(); } - return v; + return o; } template @@ -62,4 +62,3 @@ inline void object::as() const } // namespace msgpack #endif /* msgpack/type/nil.hpp */ - diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp index a309cac7..851d00c3 100644 --- a/include/msgpack/adaptor/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -25,13 +25,13 @@ namespace msgpack { template -inline std::pair& operator>> (object const& o, std::pair& v) +inline object const& operator>> (object const& o, std::pair& v) { if(o.type != type::ARRAY) { throw type_error(); } if(o.via.array.size != 2) { throw type_error(); } o.via.array.ptr[0].convert(v.first); o.via.array.ptr[1].convert(v.second); - return v; + return o; } template @@ -58,4 +58,3 @@ inline void operator<< (object::with_zone& o, const std::pair& v) } // namespace msgpack #endif /* msgpack/type/pair.hpp */ - diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp index 0d41b846..e2268607 100644 --- a/include/msgpack/adaptor/raw.hpp +++ b/include/msgpack/adaptor/raw.hpp @@ -61,12 +61,12 @@ struct raw_ref { } // namespace type -inline type::raw_ref& operator>> (object const& o, type::raw_ref& v) +inline object const& operator>> (object const& o, type::raw_ref& v) { if(o.type != type::BIN) { throw type_error(); } v.ptr = o.via.bin.ptr; v.size = o.via.bin.size; - return v; + return o; } template @@ -91,4 +91,3 @@ inline void operator<< (object::with_zone& o, const type::raw_ref& v) } // namespace msgpack #endif /* msgpack/type/raw.hpp */ - diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index bea26203..f949944e 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::set& operator>> (object const& o, std::set& v) +inline object const& operator>> (object const& o, std::set& v) { if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; @@ -34,7 +34,7 @@ inline std::set& operator>> (object const& o, std::set& v) --p; v.insert(p->as()); } - return v; + return o; } template @@ -71,7 +71,7 @@ inline void operator<< (object::with_zone& o, const std::set& v) template -inline std::multiset& operator>> (object const& o, std::multiset& v) +inline object const& operator>> (object const& o, std::multiset& v) { if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; @@ -80,7 +80,7 @@ inline std::multiset& operator>> (object const& o, std::multiset& v) --p; v.insert(p->as()); } - return v; + return o; } template @@ -119,4 +119,3 @@ inline void operator<< (object::with_zone& o, const std::multiset& v) } // namespace msgpack #endif /* msgpack/type/set.hpp */ - diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp index 19964a54..a1ea2f8c 100644 --- a/include/msgpack/adaptor/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -24,7 +24,7 @@ namespace msgpack { -inline std::string& operator>> (object const& o, std::string& v) +inline object const& operator>> (object const& o, std::string& v) { switch (o.type) { case type::BIN: @@ -37,7 +37,7 @@ inline std::string& operator>> (object const& o, std::string& v) throw type_error(); break; } - return v; + return o; } template @@ -68,4 +68,3 @@ inline void operator<< (object& o, const std::string& v) } // namespace msgpack #endif /* msgpack/type/string.hpp */ - diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index ebd0d67a..6495fa9b 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -44,7 +44,7 @@ namespace msgpack { template -inline MSGPACK_STD_TR1::unordered_map& operator>> (object o, MSGPACK_STD_TR1::unordered_map& v) +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -54,7 +54,7 @@ inline MSGPACK_STD_TR1::unordered_map& operator>> (object o, MSGPACK_STD_T p->key.convert(key); p->val.convert(v[key]); } - return v; + return o; } template @@ -93,7 +93,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m template -inline MSGPACK_STD_TR1::unordered_multimap& operator>> (object o, MSGPACK_STD_TR1::unordered_multimap& v) +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multimap& v) { if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); @@ -104,7 +104,7 @@ inline MSGPACK_STD_TR1::unordered_multimap& operator>> (object o, MSGPACK_ p->val.convert(value.second); v.insert(value); } - return v; + return o; } template diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index bf7fc7c8..e6086c09 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -43,7 +43,7 @@ namespace msgpack { template -inline MSGPACK_STD_TR1::unordered_set& operator>> (object o, MSGPACK_STD_TR1::unordered_set& v) +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set& v) { if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; @@ -52,7 +52,7 @@ inline MSGPACK_STD_TR1::unordered_set& operator>> (object o, MSGPACK_STD_TR1: --p; v.insert(p->as()); } - return v; + return o; } template @@ -89,7 +89,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s template -inline MSGPACK_STD_TR1::unordered_multiset& operator>> (object o, MSGPACK_STD_TR1::unordered_multiset& v) +inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multiset& v) { if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; @@ -98,7 +98,7 @@ inline MSGPACK_STD_TR1::unordered_multiset& operator>> (object o, MSGPACK_STD --p; v.insert(p->as()); } - return v; + return o; } template @@ -139,4 +139,3 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m #undef MSGPACK_STD_TR1 #endif /* msgpack/type/set.hpp */ - diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index 0123a3b6..73856896 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -25,7 +25,7 @@ namespace msgpack { template -inline std::vector& operator>> (object const& o, std::vector& v) +inline object const& operator>> (object const& o, std::vector& v) { if(o.type != type::ARRAY) { throw type_error(); } v.resize(o.via.array.size); @@ -39,7 +39,7 @@ inline std::vector& operator>> (object const& o, std::vector& v) ++it; } while(p < pend); } - return v; + return o; } template @@ -78,4 +78,3 @@ inline void operator<< (object::with_zone& o, const std::vector& v) } // namespace msgpack #endif /* msgpack/type/vector.hpp */ - diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp index 9ada3e6c..d87081d0 100644 --- a/include/msgpack/adaptor/vector_char.hpp +++ b/include/msgpack/adaptor/vector_char.hpp @@ -23,7 +23,7 @@ namespace msgpack { -inline std::vector& operator>> (object const& o, std::vector& v) +inline object const& operator>> (object const& o, std::vector& v) { switch (o.type) { case type::BIN: @@ -38,7 +38,7 @@ inline std::vector& operator>> (object const& o, std::vector& v) throw type_error(); break; } - return v; + return o; } template @@ -69,4 +69,3 @@ inline void operator<< (object::with_zone& o, const std::vector& v) } // namespace msgpack #endif // MSGPACK_TYPE_VECTOR_CHAR_HPP - diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index 4b05cc23..f060450b 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -188,18 +188,18 @@ inline packer& packer::pack(const T& v) return *this; } -inline object& operator>> (object const& o, object& v) +inline object const& operator>> (object const& o, object& v) { v = o; - return v; + return o; } // convert operator template -inline T& operator>> (object const& o, T& v) +inline object const& operator>> (object const& o, T& v) { v.msgpack_unpack(o.convert()); - return v; + return o; } namespace detail { From a388000d4719ebd0b89741a5b840124e0ec23aed Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 31 Aug 2014 20:38:52 +0900 Subject: [PATCH 119/153] Fixed autotools AC_INIT with external information implemantation. See: http://stackoverflow.com/questions/22871340/using-a-variable-in-ac-init --- configure.in | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/configure.in b/configure.in index fdf53c2e..ef5150d5 100644 --- a/configure.in +++ b/configure.in @@ -1,11 +1,7 @@ -major=`sed -n 's/#define MSGPACK_VERSION_MAJOR\s\(.*\)/\1/p' include/msgpack/version_master.h` -minor=`sed -n 's/#define MSGPACK_VERSION_MINOR\s\(.*\)/\1/p' include/msgpack/version_master.h` -release=`sed -n 's/#define MSGPACK_VERSION_RELEASE\s\(.*\)/\1/p' include/msgpack/version_master.h` -AC_INIT(msgpack, $major.$minor.$release) +AC_INIT(msgpack, m4_esyscmd([cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_RELEASE\s*\(\w*\)/\1/g'])) AC_CONFIG_AUX_DIR(ac) AM_INIT_AUTOMAKE AC_CONFIG_HEADER(config.h) - AC_SUBST(CFLAGS) CFLAGS="-O3 -Wall $CFLAGS" @@ -88,10 +84,12 @@ fi AM_CONDITIONAL(ENABLE_GCC_CXX_ATOMIC, test "$enable_gcc_cxx_atomic" = "yes") -major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'` -minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'` +major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\1/'` +minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\2/'` +release=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\3/'` AC_SUBST(VERSION_MAJOR, $major) AC_SUBST(VERSION_MINOR, $minor) +AC_SUBST(VERSION_RELEASE, $release) AC_OUTPUT([Makefile From 30b946ee85ef427d54469a60559ab8609ebc4091 Mon Sep 17 00:00:00 2001 From: Thiago de Arruda Date: Sun, 31 Aug 2014 10:32:25 -0300 Subject: [PATCH 120/153] Support out-of-tree builds with cmake This changes the location of msgpack.pc to support out-of-tree builds. --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 87906e0f..dcee3f1e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -168,7 +168,7 @@ ENDIF () INSTALL (TARGETS msgpack msgpack-static DESTINATION lib) INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX}) -INSTALL (FILES msgpack.pc DESTINATION lib/pkgconfig) +INSTALL (FILES ${CMAKE_BINARY_DIR}/msgpack.pc DESTINATION lib/pkgconfig) # Doxygen FIND_PACKAGE (Doxygen) From 2103c12e053d5d1700ccbd4b308e3fbf9837ac55 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 1 Sep 2014 22:42:08 +0900 Subject: [PATCH 121/153] Added char* packing support. char* is packed to STR similar as std::string. See https://github.com/msgpack/msgpack-c/issues/110 --- CMakeLists.txt | 1 + include/msgpack/adaptor/char_ptr.hpp | 56 ++++++++++++++++++++++++++++ include/msgpack/type.hpp | 1 + src/Makefile.am | 1 + test/msgpack_test.cpp | 17 +++++++++ test/object_with_zone.cpp | 23 +++++++++++- 6 files changed, 98 insertions(+), 1 deletion(-) create mode 100644 include/msgpack/adaptor/char_ptr.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index dcee3f1e..89da4c2e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -79,6 +79,7 @@ IF (MSGPACK_ENABLE_CXX) LIST (APPEND msgpack_HEADERS include/msgpack.hpp include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/char_ptr.hpp include/msgpack/adaptor/cpp11/array.hpp include/msgpack/adaptor/cpp11/array_char.hpp include/msgpack/adaptor/cpp11/forward_list.hpp diff --git a/include/msgpack/adaptor/char_ptr.hpp b/include/msgpack/adaptor/char_ptr.hpp new file mode 100644 index 00000000..2ef6c98b --- /dev/null +++ b/include/msgpack/adaptor/char_ptr.hpp @@ -0,0 +1,56 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_CHAR_PTR_HPP +#define MSGPACK_TYPE_CHAR_PTR_HPP + +#include "msgpack/object.hpp" +#include + +namespace msgpack { + +template +inline packer& operator<< (packer& o, const char* v) +{ + std::size_t size = std::strlen(v); + o.pack_str(size); + o.pack_str_body(v, size); + return o; +} + +inline void operator<< (object::with_zone& o, const char* v) +{ + std::size_t size = std::strlen(v); + o.type = type::STR; + char* ptr = static_cast(o.zone.allocate_align(size)); + o.via.str.ptr = ptr; + o.via.str.size = static_cast(size); + memcpy(ptr, v, size); +} + +inline void operator<< (object& o, const char* v) +{ + std::size_t size = std::strlen(v); + o.type = type::STR; + o.via.str.ptr = v; + o.via.str.size = static_cast(size); +} + + +} // namespace msgpack + +#endif // MSGPACK_TYPE_CHAR_PTR_HPP diff --git a/include/msgpack/type.hpp b/include/msgpack/type.hpp index e1ef05a8..ab10d9ed 100644 --- a/include/msgpack/type.hpp +++ b/include/msgpack/type.hpp @@ -1,5 +1,6 @@ #include "cpp_config.hpp" #include "adaptor/bool.hpp" +#include "adaptor/char_ptr.hpp" #include "adaptor/deque.hpp" #include "adaptor/fixint.hpp" #include "adaptor/float.hpp" diff --git a/src/Makefile.am b/src/Makefile.am index 37c5f776..1528d20e 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -53,6 +53,7 @@ if ENABLE_CXX nobase_include_HEADERS += \ ../include/msgpack.hpp \ ../include/msgpack/adaptor/bool.hpp \ + ../include/msgpack/adaptor/char_ptr.hpp \ ../include/msgpack/adaptor/cpp11/array.hpp \ ../include/msgpack/adaptor/cpp11/array_char.hpp \ ../include/msgpack/adaptor/cpp11/forward_list.hpp \ diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp index bef5f93a..dcbb883f 100644 --- a/test/msgpack_test.cpp +++ b/test/msgpack_test.cpp @@ -459,6 +459,23 @@ TEST(MSGPACK_STL, simple_buffer_string) } } +TEST(MSGPACK_STL, simple_buffer_cstring) +{ + for (unsigned int k = 0; k < kLoop; k++) { + string val1; + for (unsigned int i = 0; i < kElements; i++) + val1 += 'a' + rand() % 26; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1.c_str()); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); + string val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(val1, val2); + } +} + TEST(MSGPACK_STL, simple_buffer_vector) { for (unsigned int k = 0; k < kLoop; k++) { diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp index 123e570c..cb49b8b3 100644 --- a/test/object_with_zone.cpp +++ b/test/object_with_zone.cpp @@ -259,6 +259,28 @@ TEST(object_without_zone, string) EXPECT_EQ(obj.as()[0], 'd'); } +// char* +TEST(object_with_zone, char_ptr) +{ + char v[] = "abc"; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), std::string(v)); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'a'); +} + +TEST(object_without_zone, char_ptr) +{ + char v[] = "abc"; + msgpack::zone z; + msgpack::object obj(v); + EXPECT_EQ(obj.as(), std::string(v)); + v[0] = 'd'; + EXPECT_EQ(obj.as()[0], 'd'); +} + + // raw_ref TEST(object_with_zone, raw_ref) { @@ -659,4 +681,3 @@ TEST(object_with_zone, tuple) } #endif - From d15e49cb7391fe6fed65f636a4de2145138dccc3 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 2 Sep 2014 16:42:05 +0900 Subject: [PATCH 122/153] Updated version getting mechanism. Versions are gotten from version_master.h --- CMakeLists.txt | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 89da4c2e..1f9d07c4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,14 @@ CMAKE_MINIMUM_REQUIRED (VERSION 2.8.6) PROJECT (msgpack) -SET (VERSION 0.6.0) -SET (VERSION_MAJOR 0) -SET (VERSION_MINOR 6) +FILE (READ ${CMAKE_SOURCE_DIR}/include/msgpack/version_master.h contents) +STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) +SET (VERSION_MAJOR ${CMAKE_MATCH_1}) +STRING (REGEX MATCH "#define MSGPACK_VERSION_MINOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) +SET (VERSION_MINOR ${CMAKE_MATCH_1}) +STRING (REGEX MATCH "#define MSGPACK_VERSION_RELEASE *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) +SET (VERSION_RELEASE ${CMAKE_MATCH_1}) +SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_RELEASE}) SET (prefix ${CMAKE_INSTALL_PREFIX}) SET (exec_prefix "\${prefix}") From 5896ff3746d12be64db1744af87db0bcff0096a7 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 2 Sep 2014 18:15:58 +0900 Subject: [PATCH 123/153] Fixed -Wextra warnings on gcc. --- CMakeLists.txt | 1 + erb/cpp03_define.hpp.erb | 2 +- erb/cpp03_msgpack_tuple.hpp.erb | 6 +- include/msgpack.h | 1 + .../msgpack/adaptor/detail/cpp03_define.hpp | 2 +- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 6 +- .../msgpack/adaptor/detail/cpp11_define.hpp | 2 +- include/msgpack/adaptor/fixint.hpp | 44 +++++- include/msgpack/adaptor/int.hpp | 66 +++++++-- include/msgpack/adaptor/nil.hpp | 6 +- include/msgpack/detail/cpp11_zone.hpp | 4 +- include/msgpack/unpack.hpp | 24 ++-- include/msgpack/util.h | 23 +++ src/Makefile.am | 1 + src/unpack.c | 136 +++++++++++++++--- test/object.cpp | 2 +- test/streaming.cpp | 4 +- 17 files changed, 271 insertions(+), 59 deletions(-) create mode 100644 include/msgpack/util.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 1f9d07c4..791adb56 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -68,6 +68,7 @@ LIST (APPEND msgpack_HEADERS include/msgpack/pack_template.h include/msgpack/unpack_define.h include/msgpack/unpack_template.h + include/msgpack/util.h include/msgpack/sysdep.h include/msgpack/sbuffer.h include/msgpack/version.h diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index 04c6a0fe..27d165e0 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -82,7 +82,7 @@ struct define<> { { if(o.type != type::ARRAY) { throw type_error(); } } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const + void msgpack_object(msgpack::object* o, msgpack::zone&) const { o->type = type::ARRAY; o->via.array.ptr = nullptr; diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index f748ccfd..930f5368 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -135,7 +135,7 @@ tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::tr inline object const& operator>> ( object const& o, - type::tuple<>& v) { + type::tuple<>&) { if(o.type != type::ARRAY) { throw type_error(); } return o; } @@ -155,7 +155,7 @@ object const& operator>> ( template const packer& operator<< ( packer& o, - const type::tuple<>& v) { + const type::tuple<>&) { o.pack_array(0); return o; } @@ -173,7 +173,7 @@ const packer& operator<< ( inline void operator<< ( object::with_zone& o, - const type::tuple<>& v) { + const type::tuple<>&) { o.type = type::ARRAY; o.via.array.ptr = nullptr; o.via.array.size = 0; diff --git a/include/msgpack.h b/include/msgpack.h index 082edb84..5bb4494b 100644 --- a/include/msgpack.h +++ b/include/msgpack.h @@ -21,6 +21,7 @@ * @} */ +#include "msgpack/util.h" #include "msgpack/object.h" #include "msgpack/zone.h" #include "msgpack/pack.h" diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index 675690c2..8e2b4b2a 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -82,7 +82,7 @@ struct define<> { { if(o.type != type::ARRAY) { throw type_error(); } } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const + void msgpack_object(msgpack::object* o, msgpack::zone&) const { o->type = type::ARRAY; o->via.array.ptr = nullptr; diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp index d17fd703..8be8dd71 100644 --- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -10582,7 +10582,7 @@ tuple> ( object const& o, - type::tuple<>& v) { + type::tuple<>&) { if(o.type != type::ARRAY) { throw type_error(); } return o; } @@ -11439,7 +11439,7 @@ object const& operator>> ( template const packer& operator<< ( packer& o, - const type::tuple<>& v) { + const type::tuple<>&) { o.pack_array(0); return o; } @@ -12263,7 +12263,7 @@ const packer& operator<< ( inline void operator<< ( object::with_zone& o, - const type::tuple<>& v) { + const type::tuple<>&) { o.type = type::ARRAY; o.via.array.ptr = nullptr; o.via.array.size = 0; diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index 795a1184..eb955316 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -145,7 +145,7 @@ struct define<> { { if(o.type != type::ARRAY) { throw type_error(); } } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const + void msgpack_object(msgpack::object* o, msgpack::zone&) const { o->type = type::ARRAY; o->via.array.ptr = NULL; diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp index 3deccd10..b395850a 100644 --- a/include/msgpack/adaptor/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -115,16 +115,52 @@ inline packer& operator<< (packer& o, const type::fix_uint64& v) inline void operator<< (object& o, type::fix_int8 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +{ + if (v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} inline void operator<< (object& o, type::fix_int16 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +{ + if(v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} inline void operator<< (object& o, type::fix_int32 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +{ + if (v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} inline void operator<< (object& o, type::fix_int64 v) - { v.get() < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v.get() : o.type = type::POSITIVE_INTEGER, o.via.u64 = v.get(); } +{ + if (v.get() < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v.get(); + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v.get(); + } +} inline void operator<< (object& o, type::fix_uint8 v) diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp index 726bf7d3..305af663 100644 --- a/include/msgpack/adaptor/int.hpp +++ b/include/msgpack/adaptor/int.hpp @@ -98,8 +98,14 @@ namespace detail { template <> struct object_char_sign { static inline void make(object& o, char v) { - v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v - : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } } }; @@ -205,20 +211,64 @@ inline void operator<< (object& o, char v) inline void operator<< (object& o, signed char v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} inline void operator<< (object& o, signed short v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} inline void operator<< (object& o, signed int v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} inline void operator<< (object& o, signed long v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else { + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} inline void operator<< (object& o, signed long long v) - { v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } - +{ + if (v < 0) { + o.type = type::NEGATIVE_INTEGER; + o.via.i64 = v; + } + else{ + o.type = type::POSITIVE_INTEGER; + o.via.u64 = v; + } +} inline void operator<< (object& o, unsigned char v) { o.type = type::POSITIVE_INTEGER, o.via.u64 = v; } diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp index 9f8a12ea..f52d4ffe 100644 --- a/include/msgpack/adaptor/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -29,20 +29,20 @@ struct nil { }; } // namespace type -inline object const& operator>> (object const& o, type::nil& v) +inline object const& operator>> (object const& o, type::nil&) { if(o.type != type::NIL) { throw type_error(); } return o; } template -inline packer& operator<< (packer& o, const type::nil& v) +inline packer& operator<< (packer& o, const type::nil&) { o.pack_nil(); return o; } -inline void operator<< (object& o, type::nil v) +inline void operator<< (object& o, type::nil) { o.type = type::NIL; } diff --git a/include/msgpack/detail/cpp11_zone.hpp b/include/msgpack/detail/cpp11_zone.hpp index 574ee8c7..f768f008 100644 --- a/include/msgpack/detail/cpp11_zone.hpp +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -207,11 +207,11 @@ public: { ::free(p); } - static void* operator new(std::size_t size, void* mem) throw() + static void* operator new(std::size_t /*size*/, void* mem) throw() { return mem; } - static void operator delete(void *p, void* mem) throw() + static void operator delete(void * /*p*/, void* /*mem*/) throw() { } diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 652bbcbd..8c334a7e 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -149,7 +149,7 @@ inline void unpack_map_item(object& c, object const& k, object const& v) ++c.via.map.size; } -inline void unpack_str(unpack_user& u, const char* b, const char* p, uint64_t l, object& o) +inline void unpack_str(unpack_user& u, const char* p, uint64_t l, object& o) { o.type = type::STR; if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { @@ -164,7 +164,7 @@ inline void unpack_str(unpack_user& u, const char* b, const char* p, uint64_t l, o.via.str.size = l; } -inline void unpack_bin(unpack_user& u, const char* b, const char* p, uint64_t l, object& o) +inline void unpack_bin(unpack_user& u, const char* p, uint64_t l, object& o) { o.type = type::BIN; if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { @@ -370,7 +370,7 @@ public: } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr m_trail = static_cast(*m_current) & 0x1f; if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); + unpack_str(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } @@ -523,7 +523,7 @@ public: load(tmp, n); m_trail = tmp; if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); + unpack_str(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } @@ -537,7 +537,7 @@ public: load(tmp, n); m_trail = tmp; if(m_trail == 0) { - unpack_bin(m_user, data, n, m_trail, obj); + unpack_bin(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } @@ -565,7 +565,7 @@ public: load(tmp, n); m_trail = tmp; if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); + unpack_str(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } @@ -579,7 +579,7 @@ public: load(tmp, n); m_trail = tmp; if(m_trail == 0) { - unpack_bin(m_user, data, n, m_trail, obj); + unpack_bin(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } @@ -607,7 +607,7 @@ public: load(tmp, n); m_trail = tmp; if(m_trail == 0) { - unpack_str(m_user, data, n, m_trail, obj); + unpack_str(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } @@ -621,7 +621,7 @@ public: load(tmp, n); m_trail = tmp; if(m_trail == 0) { - unpack_bin(m_user, data, n, m_trail, obj); + unpack_bin(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } @@ -645,12 +645,12 @@ public: } } break; case ACS_STR_VALUE: { - unpack_str(m_user, data, n, m_trail, obj); + unpack_str(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; case ACS_BIN_VALUE: { - unpack_bin(m_user, data, n, m_trail, obj); + unpack_bin(m_user, n, m_trail, obj); int ret = push_proc(obj, off); if (ret != 0) return ret; } break; @@ -1379,7 +1379,7 @@ inline void unpack(unpacked* result, else unpack(*result, data, len, f, user_data); } -bool unpacker::default_reference_func(type::object_type type, uint64_t len, void*) +bool unpacker::default_reference_func(type::object_type /*type*/, uint64_t /*len*/, void*) { return true; } diff --git a/include/msgpack/util.h b/include/msgpack/util.h new file mode 100644 index 00000000..89b98a18 --- /dev/null +++ b/include/msgpack/util.h @@ -0,0 +1,23 @@ +/* + * MessagePack for C utilities + * + * Copyright (C) 2014 FURUHASHI Sadayuki + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_UTIL_H +#define MSGPACK_UTIL_H + +#define MSGPACK_UNUSED(a) (void)(a) + +#endif /* MSGPACK_UTIL_H */ diff --git a/src/Makefile.am b/src/Makefile.am index 1528d20e..039aeacd 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -36,6 +36,7 @@ nobase_include_HEADERS = \ ../include/msgpack/pack_template.h \ ../include/msgpack/unpack_define.h \ ../include/msgpack/unpack_template.h \ + ../include/msgpack/util.h \ ../include/msgpack/sysdep.h \ ../include/msgpack.h \ ../include/msgpack/sbuffer.h \ diff --git a/src/unpack.c b/src/unpack.c index 8b68efe6..93a8d7c3 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -17,6 +17,7 @@ */ #include "msgpack/unpack.h" #include "msgpack/unpack_define.h" +#include "msgpack/util.h" #include #ifdef _msgpack_atomic_counter_header @@ -56,50 +57,143 @@ static int template_execute( static inline msgpack_object template_callback_root(unpack_user* u) -{ msgpack_object o = { MSGPACK_OBJECT_NIL }; return o; } +{ + MSGPACK_UNUSED(u); + msgpack_object o; + o.type = MSGPACK_OBJECT_NIL; + return o; +} static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = d; + return 0; +} static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_object* o) -{ if(d >= 0) { o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; o->via.u64 = (uint64_t)d; return 0; } - else { o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; o->via.i64 = d; return 0; } } +{ + MSGPACK_UNUSED(u); + if(d >= 0) { + o->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + o->via.u64 = (uint64_t)d; + return 0; + } + else { + o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + o->via.i64 = d; + return 0; + } +} static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_DOUBLE; o->via.dec = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_DOUBLE; + o->via.dec = d; + return 0; +} static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_DOUBLE; o->via.dec = d; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_DOUBLE; + o->via.dec = d; + return 0; +} static inline int template_callback_nil(unpack_user* u, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_NIL; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_NIL; + return 0; +} static inline int template_callback_true(unpack_user* u, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_BOOLEAN; o->via.boolean = true; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_BOOLEAN; + o->via.boolean = true; + return 0; +} static inline int template_callback_false(unpack_user* u, msgpack_object* o) -{ o->type = MSGPACK_OBJECT_BOOLEAN; o->via.boolean = false; return 0; } +{ + MSGPACK_UNUSED(u); + o->type = MSGPACK_OBJECT_BOOLEAN; + o->via.boolean = false; + return 0; +} static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o) { @@ -112,6 +206,7 @@ static inline int template_callback_array(unpack_user* u, unsigned int n, msgpac static inline int template_callback_array_item(unpack_user* u, msgpack_object* c, msgpack_object o) { + MSGPACK_UNUSED(u); #if defined(__GNUC__) && !defined(__clang__) memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object)); #else /* __GNUC__ && !__clang__ */ @@ -132,6 +227,7 @@ static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_ static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v) { + MSGPACK_UNUSED(u); #if defined(__GNUC__) && !defined(__clang__) memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object)); memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object)); @@ -145,6 +241,8 @@ static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { + MSGPACK_UNUSED(u); + MSGPACK_UNUSED(b); o->type = MSGPACK_OBJECT_STR; o->via.str.ptr = p; o->via.str.size = l; @@ -154,6 +252,8 @@ static inline int template_callback_str(unpack_user* u, const char* b, const cha static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { + MSGPACK_UNUSED(u); + MSGPACK_UNUSED(b); o->type = MSGPACK_OBJECT_BIN; o->via.bin.ptr = p; o->via.bin.size = l; diff --git a/test/object.cpp b/test/object.cpp index 88490fb5..0cb5c889 100644 --- a/test/object.cpp +++ b/test/object.cpp @@ -5,7 +5,7 @@ struct myclass { myclass() : num(0), str("default") { } myclass(int num, const std::string& str) : - num(0), str("default") { } + num(num), str(str) { } ~myclass() { } diff --git a/test/streaming.cpp b/test/streaming.cpp index 2daa98a1..b9d2199e 100644 --- a/test/streaming.cpp +++ b/test/streaming.cpp @@ -175,7 +175,7 @@ public: } } - void on_message(msgpack::object obj, msgpack::unique_ptr z) + void on_message(msgpack::object obj, msgpack::unique_ptr) { EXPECT_EQ(expect, obj.as()); } @@ -283,7 +283,7 @@ public: } } - void on_message(msgpack::object obj, msgpack::unique_ptr z) + void on_message(msgpack::object obj, msgpack::unique_ptr) { EXPECT_EQ(expect, obj.as()); } From a0f53928766f1d85a65f2fbe51274cc41b2708b3 Mon Sep 17 00:00:00 2001 From: Jason Newton Date: Mon, 1 Sep 2014 21:42:44 -0700 Subject: [PATCH 124/153] correct paths for x86_64/generic installations --- CMakeLists.txt | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 791adb56..b3c6473b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -173,9 +173,13 @@ IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") ENDIF () ENDIF () -INSTALL (TARGETS msgpack msgpack-static DESTINATION lib) +IF (NOT DEFINED CMAKE_INSTALL_LIBDIR) + SET(CMAKE_INSTALL_LIBDIR lib) +ENDIF () + +INSTALL (TARGETS msgpack msgpack-static DESTINATION ${CMAKE_INSTALL_LIBDIR}) INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX}) -INSTALL (FILES ${CMAKE_BINARY_DIR}/msgpack.pc DESTINATION lib/pkgconfig) +INSTALL (FILES ${CMAKE_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) # Doxygen FIND_PACKAGE (Doxygen) From 93d0f0bd001a83e8fcffa81d364a26df66e48235 Mon Sep 17 00:00:00 2001 From: Jason Newton Date: Mon, 1 Sep 2014 23:03:55 -0700 Subject: [PATCH 125/153] inline default_reference_func to avoid multiple definition errors --- include/msgpack/unpack.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index 8c334a7e..c009517d 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -1379,7 +1379,7 @@ inline void unpack(unpacked* result, else unpack(*result, data, len, f, user_data); } -bool unpacker::default_reference_func(type::object_type /*type*/, uint64_t /*len*/, void*) +inline bool unpacker::default_reference_func(type::object_type /*type*/, uint64_t /*len*/, void*) { return true; } From 86ad026f119e9d7b56024ead1303be094c20abf4 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 3 Sep 2014 13:26:34 +0900 Subject: [PATCH 126/153] Renamed the last digit of version string from RELEASE to REVISION. Added REVISION macro and getting API. --- CMakeLists.txt | 6 +++--- configure.in | 6 +++--- include/msgpack/version.h | 4 ++-- include/msgpack/version.hpp | 8 ++++++-- include/msgpack/version_master.h | 6 +++--- src/version.c | 5 +++++ test/version.cpp | 15 ++++++++------- 7 files changed, 30 insertions(+), 20 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b3c6473b..e893c548 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,9 +6,9 @@ STRING (REGEX MATCH "#define MSGPACK_VERSION_MAJOR *([0-9a-zA-Z_]*)" NULL_OUT ${ SET (VERSION_MAJOR ${CMAKE_MATCH_1}) STRING (REGEX MATCH "#define MSGPACK_VERSION_MINOR *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) SET (VERSION_MINOR ${CMAKE_MATCH_1}) -STRING (REGEX MATCH "#define MSGPACK_VERSION_RELEASE *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) -SET (VERSION_RELEASE ${CMAKE_MATCH_1}) -SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_RELEASE}) +STRING (REGEX MATCH "#define MSGPACK_VERSION_REVISION *([0-9a-zA-Z_]*)" NULL_OUT ${contents}) +SET (VERSION_REVISION ${CMAKE_MATCH_1}) +SET (VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_REVISION}) SET (prefix ${CMAKE_INSTALL_PREFIX}) SET (exec_prefix "\${prefix}") diff --git a/configure.in b/configure.in index ef5150d5..d53cf534 100644 --- a/configure.in +++ b/configure.in @@ -1,4 +1,4 @@ -AC_INIT(msgpack, m4_esyscmd([cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_RELEASE\s*\(\w*\)/\1/g'])) +AC_INIT(msgpack, m4_esyscmd([cat include/msgpack/version_master.h | tr -d "\n" | sed -e 's/#define MSGPACK_VERSION_MAJOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_MINOR\s*\(\w*\)/\1./g' -e 's/#define MSGPACK_VERSION_REVISION\s*\(\w*\)/\1/g'])) AC_CONFIG_AUX_DIR(ac) AM_INIT_AUTOMAKE AC_CONFIG_HEADER(config.h) @@ -86,10 +86,10 @@ AM_CONDITIONAL(ENABLE_GCC_CXX_ATOMIC, test "$enable_gcc_cxx_atomic" = "yes") major=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\1/'` minor=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\2/'` -release=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\3/'` +revision=`echo $VERSION | sed 's/\([[0-9]]*\)\.\([[0-9]]*\).\([[0-9]]*\).*/\3/'` AC_SUBST(VERSION_MAJOR, $major) AC_SUBST(VERSION_MINOR, $minor) -AC_SUBST(VERSION_RELEASE, $release) +AC_SUBST(VERSION_REVISION, $revision) AC_OUTPUT([Makefile diff --git a/include/msgpack/version.h b/include/msgpack/version.h index 2a324e5c..233fa818 100644 --- a/include/msgpack/version.h +++ b/include/msgpack/version.h @@ -30,9 +30,9 @@ int msgpack_version_minor(void); #include "version_master.h" #define MSGPACK_STR(v) #v -#define MSGPACK_VERSION_I(maj, min, rel) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rel) +#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) -#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_RELEASE) +#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) #ifdef __cplusplus } diff --git a/include/msgpack/version.hpp b/include/msgpack/version.hpp index d9e2f371..d1ccd89e 100644 --- a/include/msgpack/version.hpp +++ b/include/msgpack/version.hpp @@ -21,9 +21,9 @@ #include "version_master.h" #define MSGPACK_STR(v) #v -#define MSGPACK_VERSION_I(maj, min, rel) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rel) +#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) -#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_RELEASE) +#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) inline const char* msgpack_version(void) { return MSGPACK_VERSION; @@ -37,4 +37,8 @@ inline int msgpack_version_minor(void) { return MSGPACK_VERSION_MINOR; } +inline int msgpack_version_revision(void) { + return MSGPACK_VERSION_REVISION; +} + #endif /* msgpack/version.hpp */ diff --git a/include/msgpack/version_master.h b/include/msgpack/version_master.h index cabb9718..c3154805 100644 --- a/include/msgpack/version_master.h +++ b/include/msgpack/version_master.h @@ -1,3 +1,3 @@ -#define MSGPACK_VERSION_MAJOR 0 -#define MSGPACK_VERSION_MINOR 6 -#define MSGPACK_VERSION_RELEASE 0 +#define MSGPACK_VERSION_MAJOR 0 +#define MSGPACK_VERSION_MINOR 6 +#define MSGPACK_VERSION_REVISION 0 diff --git a/src/version.c b/src/version.c index 78e06527..83f75108 100644 --- a/src/version.c +++ b/src/version.c @@ -15,3 +15,8 @@ int msgpack_version_minor(void) return MSGPACK_VERSION_MINOR; } +int msgpack_version_revision(void) +{ + return MSGPACK_VERSION_REVISION; +} + diff --git a/test/version.cpp b/test/version.cpp index d2809b21..6bb39018 100644 --- a/test/version.cpp +++ b/test/version.cpp @@ -3,11 +3,12 @@ TEST(version, print) { - printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); - printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); - printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); - printf("msgpack_version() : %s\n", msgpack_version()); - printf("msgpack_version_major() : %d\n", msgpack_version_major()); - printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); + printf("MSGPACK_VERSION : %s\n", MSGPACK_VERSION); + printf("MSGPACK_VERSION_MAJOR : %d\n", MSGPACK_VERSION_MAJOR); + printf("MSGPACK_VERSION_MINOR : %d\n", MSGPACK_VERSION_MINOR); + printf("MSGPACK_VERSION_REVISION : %d\n", MSGPACK_VERSION_REVISION); + printf("msgpack_version() : %s\n", msgpack_version()); + printf("msgpack_version_major() : %d\n", msgpack_version_major()); + printf("msgpack_version_minor() : %d\n", msgpack_version_minor()); + printf("msgpack_version_revision() : %d\n", msgpack_version_revision()); } - From a18672521358da8e43c854d04da4c84b6dd9e5ad Mon Sep 17 00:00:00 2001 From: Thiago de Arruda Date: Sat, 6 Sep 2014 20:01:52 -0300 Subject: [PATCH 127/153] Fix memory leak in msgpack_unpacker_next --- src/unpack.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/unpack.c b/src/unpack.c index 93a8d7c3..7af4e65d 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -492,6 +492,10 @@ void msgpack_unpacker_reset(msgpack_unpacker* mpac) msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) { + if(result->zone != NULL) { + msgpack_zone_free(result->zone); + } + int ret = msgpack_unpacker_execute(mpac); if(ret < 0) { From 11f1d5fbbd155b004dc5fe25153809330732c979 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 7 Sep 2014 13:56:07 +0900 Subject: [PATCH 128/153] Fixed https://github.com/msgpack/msgpack-c/pull/113 When the original PR was applied, the resource leak had been fixed, but a dual free problem had been happened. When msgpack_unpacker_next returns MSGPACK_UNPACK_CONTINUE, msgpack_unpacked::zone is not replaced. Then mespack_zone_free is called twice with the same object. msgpack_unpacked_destroy frees msgpack::zone when it is not NULL and set it to NULL. Also, fixed memory leak (msgpack_sbuffer) on the test code. --- src/unpack.c | 4 +--- test/streaming_c.cpp | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/unpack.c b/src/unpack.c index 7af4e65d..20a02e4b 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -492,9 +492,7 @@ void msgpack_unpacker_reset(msgpack_unpacker* mpac) msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) { - if(result->zone != NULL) { - msgpack_zone_free(result->zone); - } + msgpack_unpacked_destroy(result); int ret = msgpack_unpacker_execute(mpac); diff --git a/test/streaming_c.cpp b/test/streaming_c.cpp index 159eef76..34fbfa98 100644 --- a/test/streaming_c.cpp +++ b/test/streaming_c.cpp @@ -110,5 +110,5 @@ TEST(streaming, basic) msgpack_unpacker_destroy(&pac); msgpack_unpacked_destroy(&result); + msgpack_sbuffer_free(buffer); } - From 103a6c56e494a457a6e6ca2de78d4db398da20dd Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 8 Sep 2014 16:38:44 +0900 Subject: [PATCH 129/153] Added travis-ci support. --- .travis.yml | 26 +++++++++++++++++++++++ README.md | 2 ++ ci/build_autotools.sh | 39 +++++++++++++++++++++++++++++++++++ ci/build_cmake.sh | 48 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 115 insertions(+) create mode 100644 .travis.yml create mode 100755 ci/build_autotools.sh create mode 100755 ci/build_cmake.sh diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 00000000..520cffce --- /dev/null +++ b/.travis.yml @@ -0,0 +1,26 @@ +language: cpp +cache: + - apt +compiler: + - clang + - gcc +before_install: +# We need this line to have g++4.8 available in apt + - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test + - sudo apt-get update -qq + - sudo apt-get update + - sudo apt-get install libgtest-dev + - "cd /usr/src/gtest && sudo cmake . && sudo cmake --build . && sudo mv libg* /usr/local/lib/ ; cd -" +install: + - sudo apt-get install -qq gcc-4.8 g++-4.8 +# We want to compile with g++ 4.8 when rather than the default g++ + - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90 + +env: + - ACTION="ci/build_autotools.sh" PARAM="cpp11" + - ACTION="ci/build_autotools.sh" PARAM="cpp03" + - ACTION="ci/build_cmake.sh" PARAM="cpp11" + - ACTION="ci/build_cmake.sh" PARAM="cpp03" + +script: + - git clean -xdf && ${ACTION} ${PARAM} diff --git a/README.md b/README.md index 0f162c82..4436fcf1 100644 --- a/README.md +++ b/README.md @@ -19,6 +19,8 @@ The source for msgpack-c is held at [msgpack-c](https://github.com/msgpack/msgpa To report an issue, use the [msgpack-c issue tracker](https://github.com/msgpack/msgpack-c/issues) at github.com. +## Version +0.6.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=poc/0.6)](https://travis-ci.org/msgpack/msgpack-c) ## Using Msgpack diff --git a/ci/build_autotools.sh b/ci/build_autotools.sh new file mode 100755 index 00000000..90cfd504 --- /dev/null +++ b/ci/build_autotools.sh @@ -0,0 +1,39 @@ +#!/bin/sh + +./bootstrap +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +if [ $1 = "cpp11" ] +then + ./configure CXXFLAGS="-std=c++11" +else + ./configure +fi + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +make + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +make check + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +exit 0 diff --git a/ci/build_cmake.sh b/ci/build_cmake.sh new file mode 100755 index 00000000..92a06c7c --- /dev/null +++ b/ci/build_cmake.sh @@ -0,0 +1,48 @@ +#!/bin/sh + +mkdir build + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +cd build + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +if [ $1 = "cpp11" ] +then + cmake -DMSGPACK_CXX11=ON .. +else + cmake .. +fi + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +make + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +make test + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + +exit 0 From 865528f77886e45dfb60de776e0d40d2b39d9709 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 8 Sep 2014 17:01:04 +0900 Subject: [PATCH 130/153] Limited branches for travis-ci. --- .travis.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 520cffce..f0238471 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,7 +15,9 @@ install: - sudo apt-get install -qq gcc-4.8 g++-4.8 # We want to compile with g++ 4.8 when rather than the default g++ - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90 - +branches: + only: + - poc/0.6 env: - ACTION="ci/build_autotools.sh" PARAM="cpp11" - ACTION="ci/build_autotools.sh" PARAM="cpp03" From 7737f1cb7717240c4382a99b3b6221d17b5467c8 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 8 Sep 2014 17:14:56 +0900 Subject: [PATCH 131/153] Removed unused member variable. --- include/msgpack/unpack.hpp | 1 - 1 file changed, 1 deletion(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index c009517d..d6199145 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -840,7 +840,6 @@ public: private: object m_obj; msgpack::unique_ptr m_zone; - bool m_referenced; }; From dfa277a9e019fc9e55549410f43f24f54a8e995b Mon Sep 17 00:00:00 2001 From: Thiago de Arruda Date: Mon, 8 Sep 2014 09:34:09 -0300 Subject: [PATCH 132/153] Add EXT support to C library --- include/msgpack/object.h | 7 ++++ include/msgpack/pack.h | 3 ++ include/msgpack/pack_template.h | 67 +++++++++++++++++++++++++++++++ include/msgpack/unpack_template.h | 67 ++++++++++++++++++------------- src/objectc.c | 19 +++++++++ src/unpack.c | 12 ++++++ 6 files changed, 146 insertions(+), 29 deletions(-) diff --git a/include/msgpack/object.h b/include/msgpack/object.h index 560008fe..3d0d1225 100644 --- a/include/msgpack/object.h +++ b/include/msgpack/object.h @@ -69,6 +69,12 @@ typedef struct { const char* ptr; } msgpack_object_bin; +typedef struct { + int8_t type; + uint32_t size; + const char* ptr; +} msgpack_object_ext; + typedef union { bool boolean; uint64_t u64; @@ -78,6 +84,7 @@ typedef union { msgpack_object_map map; msgpack_object_str str; msgpack_object_bin bin; + msgpack_object_ext ext; } msgpack_object_union; typedef struct msgpack_object { diff --git a/include/msgpack/pack.h b/include/msgpack/pack.h index d19c3014..ea0fbf70 100644 --- a/include/msgpack/pack.h +++ b/include/msgpack/pack.h @@ -100,6 +100,9 @@ static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l); static int msgpack_pack_bin(msgpack_packer* pk, size_t l); static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l); +static int msgpack_pack_ext(msgpack_packer* pk, size_t l, int8_t type); +static int msgpack_pack_ext_body(msgpack_packer* pk, const void* b, size_t l); + int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); diff --git a/include/msgpack/pack_template.h b/include/msgpack/pack_template.h index f86f6e8d..9426a217 100644 --- a/include/msgpack/pack_template.h +++ b/include/msgpack/pack_template.h @@ -803,6 +803,73 @@ msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l msgpack_pack_append_buffer(x, (const unsigned char*)b, l); } +/* + * Ext + */ + +msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type) +{ + switch(l) { + case 1: { + char buf[2]; + buf[0] = 0xd4; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 2: { + char buf[2]; + buf[0] = 0xd5; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 4: { + char buf[2]; + buf[0] = 0xd6; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 8: { + char buf[2]; + buf[0] = 0xd7; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + case 16: { + char buf[2]; + buf[0] = 0xd8; + buf[1] = type; + msgpack_pack_append_buffer(x, buf, 2); + } break; + default: + l += 1; + if(l < 256) { + char buf[3]; + buf[0] = 0xc7; + buf[1] = l; + buf[2] = type; + msgpack_pack_append_buffer(x, buf, 3); + } else if(l < 65536) { + char buf[4]; + buf[0] = 0xc8; + _msgpack_store16(&buf[1], l); + buf[3] = type; + msgpack_pack_append_buffer(x, buf, 4); + } else { + char buf[6]; + buf[0] = 0xc9; + _msgpack_store32(&buf[1], l); + buf[5] = type; + msgpack_pack_append_buffer(x, buf, 6); + } + break; + } +} + +msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l) +{ + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); +} + #undef msgpack_pack_inline_func #undef msgpack_pack_user #undef msgpack_pack_append_buffer diff --git a/include/msgpack/unpack_template.h b/include/msgpack/unpack_template.h index 598f552f..7e50692f 100644 --- a/include/msgpack/unpack_template.h +++ b/include/msgpack/unpack_template.h @@ -205,9 +205,10 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c case 0xc5: // bin 16 case 0xc6: // bin 32 again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - //case 0xc7: - //case 0xc8: - //case 0xc9: + case 0xc7: // ext 8 + case 0xc8: // ext 16 + case 0xc9: // ext 32 + again_fixed_trail(NEXT_CS(p), 1 << ((((unsigned int)*p) + 1) & 0x03)); case 0xca: // float case 0xcb: // double case 0xcc: // unsigned int 8 @@ -219,11 +220,15 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c case 0xd2: // signed int 32 case 0xd3: // signed int 64 again_fixed_trail(NEXT_CS(p), 1 << (((unsigned int)*p) & 0x03)); - //case 0xd4: - //case 0xd5: - //case 0xd6: // big integer 16 - //case 0xd7: // big integer 32 - //case 0xd8: // big float 16 + case 0xd4: // fixext 1 + case 0xd5: // fixext 2 + case 0xd6: // fixext 4 + case 0xd7: // fixext 8 + again_fixed_trail_if_zero(ACS_EXT_VALUE, + (1 << (((unsigned int)*p) & 0x03)) + 1, _ext_zero); + case 0xd8: // fixext 16 + again_fixed_trail_if_zero(ACS_EXT_VALUE, 16+1, _ext_zero); + case 0xd9: // str 8 case 0xda: // str 16 case 0xdb: // str 32 @@ -304,31 +309,22 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c _msgpack_load64(int64_t,n,&tmp); push_fixed_value(_int64, tmp); } - - //case CS_ - //case CS_ - //case CS_BIG_INT_16: - // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load16(uint16_t,n), _big_int_zero); - //case CS_BIG_INT_32: - // again_fixed_trail_if_zero(ACS_BIG_INT_VALUE, _msgpack_load32(uint32_t,n), _big_int_zero); - //case ACS_BIG_INT_VALUE: - //_big_int_zero: - // // FIXME - // push_variable_value(_big_int, data, n, trail); - - //case CS_BIG_FLOAT_16: - // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load16(uint16_t,n), _big_float_zero); - //case CS_BIG_FLOAT_32: - // again_fixed_trail_if_zero(ACS_BIG_FLOAT_VALUE, _msgpack_load32(uint32_t,n), _big_float_zero); - //case ACS_BIG_FLOAT_VALUE: - //_big_float_zero: - // // FIXME - // push_variable_value(_big_float, data, n, trail); - + case CS_FIXEXT_1: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 1+1, _ext_zero); + case CS_FIXEXT_2: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 2+1, _ext_zero); + case CS_FIXEXT_4: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 4+1, _ext_zero); + case CS_FIXEXT_8: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 8+1, _ext_zero); + case CS_FIXEXT_16: + again_fixed_trail_if_zero(ACS_EXT_VALUE, 16+1, _ext_zero); case CS_STR_8: again_fixed_trail_if_zero(ACS_STR_VALUE, *(uint8_t*)n, _str_zero); case CS_BIN_8: again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); + case CS_EXT_8: + again_fixed_trail_if_zero(ACS_EXT_VALUE, *(uint8_t*)n, _ext_zero); case CS_STR_16:{ uint16_t tmp; _msgpack_load16(uint16_t,n,&tmp); @@ -339,6 +335,11 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c _msgpack_load16(uint16_t,n,&tmp); again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); } + case CS_EXT_16:{ + uint16_t tmp; + _msgpack_load16(uint16_t,n,&tmp); + again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp, _ext_zero); + } case CS_STR_32:{ uint32_t tmp; _msgpack_load32(uint32_t,n,&tmp); @@ -349,12 +350,20 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c _msgpack_load32(uint32_t,n,&tmp); again_fixed_trail_if_zero(ACS_BIN_VALUE, tmp, _bin_zero); } + case CS_EXT_32:{ + uint32_t tmp; + _msgpack_load32(uint32_t,n,&tmp); + again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp, _ext_zero); + } case ACS_STR_VALUE: _str_zero: push_variable_value(_str, data, n, trail); case ACS_BIN_VALUE: _bin_zero: push_variable_value(_bin, data, n, trail); + case ACS_EXT_VALUE: + _ext_zero: + push_variable_value(_ext, data, n, trail); case CS_ARRAY_16:{ uint16_t tmp; diff --git a/src/objectc.c b/src/objectc.c index ff5f6882..840d4332 100644 --- a/src/objectc.c +++ b/src/objectc.c @@ -68,6 +68,13 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d) return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); } + case MSGPACK_OBJECT_EXT: + { + int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type); + if(ret < 0) { return ret; } + return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size); + } + case MSGPACK_OBJECT_ARRAY: { int ret = msgpack_pack_array(pk, d.via.array.size); @@ -141,6 +148,13 @@ void msgpack_object_print(FILE* out, msgpack_object o) fprintf(out, "\""); break; + case MSGPACK_OBJECT_EXT: + fprintf(out, "(ext: %" PRIi8 ")", o.via.ext.type); + fprintf(out, "\""); + fwrite(o.via.ext.ptr, o.via.ext.size, 1, out); + fprintf(out, "\""); + break; + case MSGPACK_OBJECT_ARRAY: fprintf(out, "["); if(o.via.array.size != 0) { @@ -209,6 +223,11 @@ bool msgpack_object_equal(const msgpack_object x, const msgpack_object y) return x.via.bin.size == y.via.bin.size && memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + case MSGPACK_OBJECT_EXT: + return x.via.ext.size == y.via.ext.size && + x.via.ext.type == y.via.ext.type && + memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; + case MSGPACK_OBJECT_ARRAY: if(x.via.array.size != y.via.array.size) { return false; diff --git a/src/unpack.c b/src/unpack.c index 20a02e4b..33b1bec0 100644 --- a/src/unpack.c +++ b/src/unpack.c @@ -261,6 +261,18 @@ static inline int template_callback_bin(unpack_user* u, const char* b, const cha return 0; } +static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) +{ + MSGPACK_UNUSED(u); + MSGPACK_UNUSED(b); + o->type = MSGPACK_OBJECT_EXT; + o->via.ext.type = *p; + o->via.ext.ptr = p + 1; + o->via.ext.size = l - 1; + u->referenced = true; + return 0; +} + #include "msgpack/unpack_template.h" From 896dead7cc1ec6b96bdc18f828899f9dd28a6afb Mon Sep 17 00:00:00 2001 From: Thiago de Arruda Date: Mon, 8 Sep 2014 12:01:03 -0300 Subject: [PATCH 133/153] Adapt msgpack_test.cpp EXT cases to msgpackc_test.cpp --- test/msgpackc_test.cpp | 254 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 254 insertions(+) diff --git a/test/msgpackc_test.cpp b/test/msgpackc_test.cpp index 9c1977b0..7d832002 100644 --- a/test/msgpackc_test.cpp +++ b/test/msgpackc_test.cpp @@ -318,6 +318,260 @@ TEST(MSGPACKC, simple_buffer_false) msgpack_sbuffer_destroy(&sbuf); } +TEST(MSGPACKC, simple_buffer_fixext1) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf[] = { 2 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(1, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(2, obj.via.ext.ptr[0]); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext2) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf[] = { 2, 3 }; + + msgpack_pack_ext(&pk, sizeof(buf), 0); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(2, obj.via.ext.size); + EXPECT_EQ(0, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext4) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf[] = { 2, 3, 4, 5 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(4, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext8) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(8, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext16) +{ + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; + + msgpack_pack_ext(&pk, sizeof(buf), 1); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(16, obj.via.ext.size); + EXPECT_EQ(1, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_1byte_0) +{ + const size_t size = 0; + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 77); + // fprintf(stderr, "size: %u, data: \"", sbuf.size); + // for (size_t i = 0; i < sbuf.size; i++) + // fprintf(stderr, "%02x ", (uint8_t)sbuf.data[i]); + // fprintf(stderr, "\"\n"); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(77, obj.via.ext.type); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_1byte_255) +{ + const size_t size = 255; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 78); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(78, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_2byte_256) +{ + const size_t size = 256; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 79); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(79, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_2byte_65535) +{ + const size_t size = 65535; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 80); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(80, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + +TEST(MSGPACKC, simple_buffer_fixext_4byte_65536) +{ + const size_t size = 65536; + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = i; + + msgpack_sbuffer sbuf; + msgpack_sbuffer_init(&sbuf); + msgpack_packer pk; + msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write); + + msgpack_pack_ext(&pk, size, 81); + msgpack_pack_ext_body(&pk, buf, sizeof(buf)); + msgpack_zone z; + msgpack_zone_init(&z, 2048); + msgpack_object obj; + msgpack_unpack_return ret = + msgpack_unpack(sbuf.data, sbuf.size, NULL, &z, &obj); + EXPECT_EQ(MSGPACK_UNPACK_SUCCESS, ret); + EXPECT_EQ(MSGPACK_OBJECT_EXT, obj.type); + EXPECT_EQ(size, obj.via.ext.size); + EXPECT_EQ(81, obj.via.ext.type); + EXPECT_EQ(0, memcmp(buf, obj.via.ext.ptr, sizeof(buf))); + msgpack_zone_destroy(&z); + msgpack_sbuffer_destroy(&sbuf); +} + TEST(MSGPACKC, simple_buffer_array) { unsigned int array_size = 5; From aa75e6ecd3f8b684497c50f0ec159530b47f988c Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 9 Sep 2014 06:28:52 +0900 Subject: [PATCH 134/153] Fixed the path of the msgpack.pc to support structured build. --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e893c548..ad9db212 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -179,7 +179,7 @@ ENDIF () INSTALL (TARGETS msgpack msgpack-static DESTINATION ${CMAKE_INSTALL_LIBDIR}) INSTALL (DIRECTORY include DESTINATION ${CMAKE_INSTALL_PREFIX}) -INSTALL (FILES ${CMAKE_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) +INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/msgpack.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) # Doxygen FIND_PACKAGE (Doxygen) From 32b65dba479baacd7aa8322e337401f7a1e9eb2e Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 9 Sep 2014 07:37:29 +0900 Subject: [PATCH 135/153] Added 'make install' as a test target. --- ci/build_autotools.sh | 8 ++++++++ ci/build_cmake.sh | 8 ++++++++ 2 files changed, 16 insertions(+) diff --git a/ci/build_autotools.sh b/ci/build_autotools.sh index 90cfd504..a616a0da 100755 --- a/ci/build_autotools.sh +++ b/ci/build_autotools.sh @@ -36,4 +36,12 @@ then exit $ret fi +make install DESTDIR=`pwd`/install + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + exit 0 diff --git a/ci/build_cmake.sh b/ci/build_cmake.sh index 92a06c7c..24a8afe3 100755 --- a/ci/build_cmake.sh +++ b/ci/build_cmake.sh @@ -45,4 +45,12 @@ then exit $ret fi +make install DESTDIR=`pwd`/install + +ret=$? +if [ $ret -ne 0 ] +then + exit $ret +fi + exit 0 From 7491c1996a794cfe2e26cb9be56bd3f2cdd92e21 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 9 Sep 2014 13:38:07 +0900 Subject: [PATCH 136/153] Added memory checking for travis-ci cmake build. --- .travis.yml | 1 + CMakeLists.txt | 3 +++ ci/build_cmake.sh | 18 +++++++++++++++++- 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index f0238471..9475e13e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,6 +9,7 @@ before_install: - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test - sudo apt-get update -qq - sudo apt-get update + - sudo apt-get install valgrind - sudo apt-get install libgtest-dev - "cd /usr/src/gtest && sudo cmake . && sudo cmake --build . && sudo mv libg* /usr/local/lib/ ; cd -" install: diff --git a/CMakeLists.txt b/CMakeLists.txt index ad9db212..7c2dcceb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -158,6 +158,9 @@ SET_TARGET_PROPERTIES (msgpack PROPERTIES SOVERSION 3 VERSION 4.0.0) IF (MSGPACK_BUILD_TESTS) ENABLE_TESTING () + SET(CTEST_MEMORYCHECK_COMMAND "/usr/bin/valgrind") + INCLUDE(Dart) + SET(MEMORYCHECK_COMMAND_OPTIONS "--leak-check=full --error-exitcode=1") ADD_SUBDIRECTORY (test) ENDIF () diff --git a/ci/build_cmake.sh b/ci/build_cmake.sh index 24a8afe3..4f57fe9b 100755 --- a/ci/build_cmake.sh +++ b/ci/build_cmake.sh @@ -1,4 +1,4 @@ -#!/bin/sh +#!/bin/bash mkdir build @@ -53,4 +53,20 @@ then exit $ret fi +ctest -T memcheck | tee memcheck.log + +ret=${PIPESTATUS[0]} +if [ $ret -ne 0 ] +then + exit $ret +fi + +cat memcheck.log | grep "Memory Leak" > /dev/null + +ret=$? +if [ $ret -eq 0 ] +then + exit 1 +fi + exit 0 From 6a8412d6de63479577ae3dda899adebc68c77c11 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 9 Sep 2014 14:15:21 +0900 Subject: [PATCH 137/153] Separated msgpack_test.cpp. Renamed test files. Decreased test's loop counter to avoid travis-ci no output timeout. The number of loops is not so meaningful. --- test/CMakeLists.txt | 9 +- test/Makefile.am | 21 +- test/msgpack_basic.cpp | 474 ++++++ test/{msgpackc_test.cpp => msgpack_c.cpp} | 0 test/msgpack_container.cpp | 564 +++++++ ...gpack_test_cpp11.cpp => msgpack_cpp11.cpp} | 0 test/msgpack_stream.cpp | 153 ++ test/msgpack_test.cpp | 1401 ----------------- test/msgpack_vref.cpp | 270 ++++ test/object_with_zone.cpp | 2 +- 10 files changed, 1483 insertions(+), 1411 deletions(-) create mode 100644 test/msgpack_basic.cpp rename test/{msgpackc_test.cpp => msgpack_c.cpp} (100%) create mode 100644 test/msgpack_container.cpp rename test/{msgpack_test_cpp11.cpp => msgpack_cpp11.cpp} (100%) create mode 100644 test/msgpack_stream.cpp delete mode 100644 test/msgpack_test.cpp create mode 100644 test/msgpack_vref.cpp diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index eed53ec6..3c971a29 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -22,14 +22,17 @@ LIST (APPEND check_PROGRAMS fixint.cpp fixint_c.cpp msgpack_tuple.cpp - msgpack_test.cpp - msgpackc_test.cpp + msgpack_basic.cpp + msgpack_container.cpp + msgpack_stream.cpp + msgpack_vref.cpp + msgpack_c.cpp reference.cpp ) IF (MSGPACK_CXX11) LIST (APPEND check_PROGRAMS - msgpack_test_cpp11.cpp + msgpack_cpp11.cpp ) ENDIF () diff --git a/test/Makefile.am b/test/Makefile.am index 64b296fd..35859b3a 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -17,9 +17,12 @@ check_PROGRAMS = \ fixint_c \ version \ msgpack_tuple \ - msgpackc_test \ - msgpack_test \ - msgpack_test_cpp11 \ + msgpack_c \ + msgpack_basic \ + msgpack_container \ + msgpack_stream \ + msgpack_vref \ + msgpack_cpp11 \ reference TESTS = $(check_PROGRAMS) @@ -53,11 +56,17 @@ version_SOURCES = version.cpp msgpack_tuple_SOURCES = msgpack_tuple.cpp -msgpackc_test_SOURCES = msgpackc_test.cpp +msgpack_c_SOURCES = msgpack_c.cpp -msgpack_test_SOURCES = msgpack_test.cpp +msgpack_basic_SOURCES = msgpack_basic.cpp -msgpack_test_cpp11_SOURCES = msgpack_test_cpp11.cpp +msgpack_container_SOURCES = msgpack_container.cpp + +msgpack_stream_SOURCES = msgpack_stream.cpp + +msgpack_vref_SOURCES = msgpack_vref.cpp + +msgpack_cpp11_SOURCES = msgpack_cpp11.cpp reference_SOURCES = reference.cpp diff --git a/test/msgpack_basic.cpp b/test/msgpack_basic.cpp new file mode 100644 index 00000000..bd0a8745 --- /dev/null +++ b/test/msgpack_basic.cpp @@ -0,0 +1,474 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +#define GEN_TEST(test_type) \ + do { \ + vector v; \ + v.push_back(0); \ + v.push_back(1); \ + v.push_back(2); \ + v.push_back(numeric_limits::min()); \ + v.push_back(numeric_limits::max()); \ + for (unsigned int i = 0; i < kLoop; i++) \ + v.push_back(rand()); \ + for (unsigned int i = 0; i < v.size() ; i++) { \ + msgpack::sbuffer sbuf; \ + test_type val1 = v[i]; \ + msgpack::pack(sbuf, val1); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + EXPECT_EQ(val1, ret.get().as()); \ + } \ +} while(0) + +TEST(MSGPACK, simple_buffer_char) +{ + GEN_TEST(char); +} + +TEST(MSGPACK, simple_buffer_signed_char) +{ + GEN_TEST(signed char); +} + +TEST(MSGPACK, simple_buffer_unsigned_char) +{ + GEN_TEST(unsigned char); +} + + +TEST(MSGPACK, simple_buffer_short) +{ + GEN_TEST(short); +} + +TEST(MSGPACK, simple_buffer_int) +{ + GEN_TEST(int); +} + +TEST(MSGPACK, simple_buffer_long) +{ + GEN_TEST(long); +} + +TEST(MSGPACK, simple_buffer_long_long) +{ + GEN_TEST(long long); +} + +TEST(MSGPACK, simple_buffer_unsigned_short) +{ + GEN_TEST(unsigned short); +} + +TEST(MSGPACK, simple_buffer_unsigned_int) +{ + GEN_TEST(unsigned int); +} + +TEST(MSGPACK, simple_buffer_unsigned_long) +{ + GEN_TEST(unsigned long); +} + +TEST(MSGPACK, simple_buffer_unsigned_long_long) +{ + GEN_TEST(unsigned long long); +} + +TEST(MSGPACK, simple_buffer_uint8) +{ + GEN_TEST(uint8_t); +} + +TEST(MSGPACK, simple_buffer_uint16) +{ + GEN_TEST(uint16_t); +} + +TEST(MSGPACK, simple_buffer_uint32) +{ + GEN_TEST(uint32_t); +} + +TEST(MSGPACK, simple_buffer_uint64) +{ + GEN_TEST(uint64_t); +} + +TEST(MSGPACK, simple_buffer_int8) +{ + GEN_TEST(int8_t); +} + +TEST(MSGPACK, simple_buffer_int16) +{ + GEN_TEST(int16_t); +} + +TEST(MSGPACK, simple_buffer_int32) +{ + GEN_TEST(int32_t); +} + +TEST(MSGPACK, simple_buffer_int64) +{ + GEN_TEST(int64_t); +} + +TEST(MSGPACK, simple_buffer_float) +{ + vector v; + v.push_back(0.0); + v.push_back(-0.0); + v.push_back(1.0); + v.push_back(-1.0); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + v.push_back(nanf("tag")); + v.push_back(1.0/0.0); // inf + v.push_back(-(1.0/0.0)); // -inf + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(drand48()); + v.push_back(-drand48()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + float val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float val2 = ret.get().as(); + + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); + else + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +namespace { +template +struct TypePair { + typedef F float_type; + typedef I integer_type; +}; +} // namespace + +template +class IntegerToFloatingPointTest : public testing::Test { +}; +TYPED_TEST_CASE_P(IntegerToFloatingPointTest); + +TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) +{ + typedef typename TypeParam::float_type float_type; + typedef typename TypeParam::integer_type integer_type; + vector v; + v.push_back(0); + v.push_back(1); + if (numeric_limits::is_signed) v.push_back(-1); + else v.push_back(2); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(rand()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + integer_type val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + float_type val2 = ret.get().as(); + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest, + simple_buffer); + +typedef testing::Types, + TypePair, + TypePair, + TypePair > IntegerToFloatingPointTestTypes; +INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance, + IntegerToFloatingPointTest, + IntegerToFloatingPointTestTypes); + +TEST(MSGPACK, simple_buffer_double) +{ + vector v; + v.push_back(0.0); + v.push_back(-0.0); + v.push_back(1.0); + v.push_back(-1.0); + v.push_back(numeric_limits::min()); + v.push_back(numeric_limits::max()); + v.push_back(nanf("tag")); + v.push_back(1.0/0.0); // inf + v.push_back(-(1.0/0.0)); // -inf + for (unsigned int i = 0; i < kLoop; i++) { + v.push_back(drand48()); + v.push_back(-drand48()); + } + for (unsigned int i = 0; i < v.size() ; i++) { + msgpack::sbuffer sbuf; + double val1 = v[i]; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + double val2 = ret.get().as(); + + if (std::isnan(val1)) + EXPECT_TRUE(std::isnan(val2)); + else if (std::isinf(val1)) + EXPECT_TRUE(std::isinf(val2)); + else + EXPECT_TRUE(fabs(val2 - val1) <= kEPS); + } +} + +TEST(MSGPACK, simple_buffer_true) +{ + msgpack::sbuffer sbuf; + bool val1 = true; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK, simple_buffer_false) +{ + msgpack::sbuffer sbuf; + bool val1 = false; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + bool val2 = ret.get().as(); + EXPECT_EQ(val1, val2); +} + +TEST(MSGPACK, simple_buffer_fixext1) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(1, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_EQ(2, ret.get().via.ext.data()[0]); +} + +TEST(MSGPACK, simple_buffer_fixext2) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3 }; + + packer.pack_ext(sizeof(buf), 0); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(2, ret.get().via.ext.size); + EXPECT_EQ(0, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext4) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(4, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext8) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(8, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext16) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(16, ret.get().via.ext.size); + EXPECT_EQ(1, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_0) +{ + std::size_t const size = 0; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + + packer.pack_ext(size, 77); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); +} + +TEST(MSGPACK, simple_buffer_fixext_1byte_255) +{ + std::size_t const size = 255; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_256) +{ + std::size_t const size = 256; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_2byte_65535) +{ + std::size_t const size = 65535; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK, simple_buffer_fixext_4byte_65536) +{ + std::size_t const size = 65536; + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char buf[size]; + for (int i = 0; i != size; ++i) buf[i] = static_cast(i); + packer.pack_ext(sizeof(buf), 77); + packer.pack_ext_body(buf, sizeof(buf)); + + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(size, ret.get().via.ext.size); + EXPECT_EQ(77, ret.get().via.ext.type()); + EXPECT_TRUE( + std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); +} + +TEST(MSGPACK_STL, simple_buffer_string) +{ + for (unsigned int k = 0; k < kLoop; k++) { + string val1; + for (unsigned int i = 0; i < kElements; i++) + val1 += 'a' + rand() % 26; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); + string val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(val1, val2); + } +} + +TEST(MSGPACK_STL, simple_buffer_cstring) +{ + for (unsigned int k = 0; k < kLoop; k++) { + string val1; + for (unsigned int i = 0; i < kElements; i++) + val1 += 'a' + rand() % 26; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1.c_str()); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::STR); + string val2 = ret.get().as(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(val1, val2); + } +} + diff --git a/test/msgpackc_test.cpp b/test/msgpack_c.cpp similarity index 100% rename from test/msgpackc_test.cpp rename to test/msgpack_c.cpp diff --git a/test/msgpack_container.cpp b/test/msgpack_container.cpp new file mode 100644 index 00000000..5b8accf0 --- /dev/null +++ b/test/msgpack_container.cpp @@ -0,0 +1,564 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 1000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +TEST(MSGPACK_STL, simple_buffer_vector) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); + vector val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_vector_char) +{ + for (unsigned int k = 0; k < kLoop; k++) { + vector val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + EXPECT_EQ(ret.get().type, msgpack::type::BIN); + vector val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_deque) +{ + for (unsigned int k = 0; k < kLoop; k++) { + deque val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + deque val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_list) +{ + for (unsigned int k = 0; k < kLoop; k++) { + list val1; + for (unsigned int i = 0; i < kElements; i++) + val1.push_back(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + list val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); + } +} + +TEST(MSGPACK_STL, simple_buffer_pair) +{ + for (unsigned int k = 0; k < kLoop; k++) { + pair val1 = make_pair(rand(), rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + pair val2 = ret.get().as >(); + EXPECT_EQ(val1.first, val2.first); + EXPECT_EQ(val1.second, val2.second); + } +} + +TEST(MSGPACK_STL, simple_buffer_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multimap val2 = ret.get().as >(); + + vector > v1, v2; + multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} + +TEST(MSGPACK_STL, simple_buffer_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + multiset val2 = ret.get().as >(); + + vector v1, v2; + multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} + +// TR1 + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + tr1::unordered_map::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) { + EXPECT_TRUE(val2.find(it->first) != val2.end()); + EXPECT_EQ(it->second, val2.find(it->first)->second); + } + } +} + +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multimap val2 = ret.get().as >(); + + vector > v1, v2; + tr1::unordered_multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + tr1::unordered_set::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + EXPECT_TRUE(val2.find(*it) != val2.end()); + } +} + +TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + tr1::unordered_multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + tr1::unordered_multiset val2 = ret.get().as >(); + + vector v1, v2; + tr1::unordered_multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#include "msgpack/adaptor/tr1/unordered_map.hpp" +TEST(MSGPACK_TR1, simple_buffer_unordered_map) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_map val1; + for (unsigned int i = 0; i < kElements; i++) + val1[rand()] = rand(); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_map val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + unordered_map::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) { + EXPECT_TRUE(val2.find(it->first) != val2.end()); + EXPECT_EQ(it->second, val2.find(it->first)->second); + } + } +} + +TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_multimap val1; + for (unsigned int i = 0; i < kElements; i++) { + int i1 = rand(); + val1.insert(make_pair(i1, rand())); + val1.insert(make_pair(i1, rand())); + } + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multimap val2 = ret.get().as >(); + + vector > v1, v2; + unordered_multimap::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(make_pair(it->first, it->second)); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(make_pair(it->first, it->second)); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + +#ifdef MSGPACK_HAS_STD_UNOURDERED_SET +#include +#include "msgpack/adaptor/tr1/unordered_set.hpp" +TEST(MSGPACK_TR1, simple_buffer_unordered_set) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_set val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_set val2 = ret.get().as >(); + EXPECT_EQ(val1.size(), val2.size()); + unordered_set::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + EXPECT_TRUE(val2.find(*it) != val2.end()); + } +} + +TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) +{ + for (unsigned int k = 0; k < kLoop; k++) { + unordered_multiset val1; + for (unsigned int i = 0; i < kElements; i++) + val1.insert(rand()); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + unordered_multiset val2 = ret.get().as >(); + + vector v1, v2; + unordered_multiset::const_iterator it; + for (it = val1.begin(); it != val1.end(); ++it) + v1.push_back(*it); + for (it = val2.begin(); it != val2.end(); ++it) + v2.push_back(*it); + EXPECT_EQ(val1.size(), val2.size()); + EXPECT_EQ(v1.size(), v2.size()); + sort(v1.begin(), v1.end()); + sort(v2.begin(), v2.end()); + EXPECT_TRUE(v1 == v2); + } +} +#endif + + +// User-Defined Structures + +class TestClass +{ +public: + TestClass() : i(0), s("kzk") {} + int i; + string s; + MSGPACK_DEFINE(i, s); +}; + +TEST(MSGPACK_USER_DEFINED, simple_buffer_class) +{ + for (unsigned int k = 0; k < kLoop; k++) { + TestClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass val2 = ret.get().as(); + EXPECT_EQ(val1.i, val2.i); + EXPECT_EQ(val1.s, val2.s); + } +} + +class TestClass2 +{ +public: + TestClass2() : i(0), s("kzk") { + for (unsigned int i = 0; i < kElements; i++) + v.push_back(rand()); + } + int i; + string s; + vector v; + MSGPACK_DEFINE(i, s, v); +}; + +TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) +{ + for (unsigned int k = 0; k < kLoop; k++) { + TestClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass2 val2 = ret.get().as(); + EXPECT_EQ(val1.i, val2.i); + EXPECT_EQ(val1.s, val2.s); + EXPECT_FALSE(val2.s.empty()); + } +} + +TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) +{ + for (unsigned int k = 0; k < kLoop; k++) { + TestClass2 val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestClass val2 = ret.get().as(); + EXPECT_EQ(val1.i, val2.i); + EXPECT_EQ(val1.s, val2.s); + EXPECT_FALSE(val2.s.empty()); + } +} + +class TestEnumMemberClass +{ +public: + TestEnumMemberClass() + : t1(STATE_A), t2(STATE_B), t3(STATE_C) {} + + enum TestEnumType { + STATE_INVALID = 0, + STATE_A = 1, + STATE_B = 2, + STATE_C = 3 + }; + TestEnumType t1; + TestEnumType t2; + TestEnumType t3; + + MSGPACK_DEFINE(t1, t2, t3); +}; + +MSGPACK_ADD_ENUM(TestEnumMemberClass::TestEnumType); + +TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) +{ + TestEnumMemberClass val1; + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestEnumMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.t1, val2.t1); + EXPECT_EQ(val1.t2, val2.t2); + EXPECT_EQ(val1.t3, val2.t3); +} + +class TestUnionMemberClass +{ +public: + TestUnionMemberClass() {} + TestUnionMemberClass(double f) { + is_double = true; + value.f = f; + } + TestUnionMemberClass(int i) { + is_double = false; + value.i = i; + } + + union { + double f; + int i; + } value; + bool is_double; + + template + void msgpack_pack(Packer& pk) const + { + if (is_double) + pk.pack(msgpack::type::tuple(true, value.f)); + else + pk.pack(msgpack::type::tuple(false, value.i)); + } + + void msgpack_unpack(msgpack::object o) + { + msgpack::type::tuple tuple; + o.convert(&tuple); + + is_double = tuple.get<0>(); + if (is_double) + tuple.get<1>().convert(&value.f); + else + tuple.get<1>().convert(&value.i); + } +}; + +TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) +{ + { + // double + TestUnionMemberClass val1(1.0); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestUnionMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.is_double, val2.is_double); + EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); + } + { + // int + TestUnionMemberClass val1(1); + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + TestUnionMemberClass val2 = ret.get().as(); + EXPECT_EQ(val1.is_double, val2.is_double); + EXPECT_EQ(val1.value.i, 1); + EXPECT_EQ(val1.value.i, val2.value.i); + } +} diff --git a/test/msgpack_test_cpp11.cpp b/test/msgpack_cpp11.cpp similarity index 100% rename from test/msgpack_test_cpp11.cpp rename to test/msgpack_cpp11.cpp diff --git a/test/msgpack_stream.cpp b/test/msgpack_stream.cpp new file mode 100644 index 00000000..2f4be819 --- /dev/null +++ b/test/msgpack_stream.cpp @@ -0,0 +1,153 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 1000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + + +#define GEN_TEST_STREAM(test_type) \ + for (unsigned int k = 0; k < kLoop; k++) { \ + msgpack::sbuffer sbuf; \ + msgpack::packer pk(sbuf); \ + typedef std::vector vec_type; \ + vec_type vec; \ + for(unsigned int i = 0; i < rand() % kLoop; ++i) { \ + vec_type::value_type r = rand(); \ + vec.push_back(r); \ + pk.pack(r); \ + } \ + msgpack::unpacker pac; \ + vec_type::const_iterator it = vec.begin(); \ + const char *p = sbuf.data(); \ + const char * const pend = p + sbuf.size(); \ + while (p < pend) { \ + const size_t sz = std::min(pend - p, rand() % 128); \ + pac.reserve_buffer(sz); \ + memcpy(pac.buffer(), p, sz); \ + pac.buffer_consumed(sz); \ + msgpack::unpacked result; \ + while (pac.next(result)) { \ + if (it == vec.end()) goto out; \ + msgpack::object obj = result.get(); \ + vec_type::value_type val; \ + obj.convert(&val); \ + EXPECT_EQ(*it, val); \ + ++it; \ + } \ + p += sz; \ + } \ + out: \ + ; \ + } + +TEST(MSGPACK, stream_char) +{ + GEN_TEST_STREAM(char); +} + +TEST(MSGPACK, stream_signed_char) +{ + GEN_TEST_STREAM(signed char); +} + +TEST(MSGPACK, stream_unsigned_char) +{ + GEN_TEST_STREAM(unsigned char); +} + +TEST(MSGPACK, stream_short) +{ + GEN_TEST_STREAM(short); +} + +TEST(MSGPACK, stream_int) +{ + GEN_TEST_STREAM(int); +} + +TEST(MSGPACK, stream_long) +{ + GEN_TEST_STREAM(long); +} + +TEST(MSGPACK, stream_long_long) +{ + GEN_TEST_STREAM(long long); +} + +TEST(MSGPACK, stream_unsigned_short) +{ + GEN_TEST_STREAM(unsigned short); +} + +TEST(MSGPACK, stream_unsigned_int) +{ + GEN_TEST_STREAM(unsigned int); +} + +TEST(MSGPACK, stream_unsigned_long) +{ + GEN_TEST_STREAM(unsigned long); +} + +TEST(MSGPACK, stream_unsigned_long_long) +{ + GEN_TEST_STREAM(unsigned long long); +} + +TEST(MSGPACK, stream_uint8) +{ + GEN_TEST_STREAM(uint8_t); +} + +TEST(MSGPACK, stream_uint16) +{ + GEN_TEST_STREAM(uint16_t); +} + +TEST(MSGPACK, stream_uint32) +{ + GEN_TEST_STREAM(uint32_t); +} + +TEST(MSGPACK, stream_uint64) +{ + GEN_TEST_STREAM(uint64_t); +} + +TEST(MSGPACK, stream_int8) +{ + GEN_TEST_STREAM(int8_t); +} + +TEST(MSGPACK, stream_int16) +{ + GEN_TEST_STREAM(int16_t); +} + +TEST(MSGPACK, stream_int32) +{ + GEN_TEST_STREAM(int32_t); +} + +TEST(MSGPACK, stream_int64) +{ + GEN_TEST_STREAM(int64_t); +} diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp deleted file mode 100644 index dcbb883f..00000000 --- a/test/msgpack_test.cpp +++ /dev/null @@ -1,1401 +0,0 @@ -#include "msgpack.hpp" - -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -using namespace std; - -const unsigned int kLoop = 10000; -const unsigned int kElements = 100; -const double kEPS = 1e-10; - -#define GEN_TEST(test_type) \ - do { \ - vector v; \ - v.push_back(0); \ - v.push_back(1); \ - v.push_back(2); \ - v.push_back(numeric_limits::min()); \ - v.push_back(numeric_limits::max()); \ - for (unsigned int i = 0; i < kLoop; i++) \ - v.push_back(rand()); \ - for (unsigned int i = 0; i < v.size() ; i++) { \ - msgpack::sbuffer sbuf; \ - test_type val1 = v[i]; \ - msgpack::pack(sbuf, val1); \ - msgpack::unpacked ret; \ - msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ - EXPECT_EQ(val1, ret.get().as()); \ - } \ -} while(0) - -TEST(MSGPACK, simple_buffer_char) -{ - GEN_TEST(char); -} - -TEST(MSGPACK, simple_buffer_signed_char) -{ - GEN_TEST(signed char); -} - -TEST(MSGPACK, simple_buffer_unsigned_char) -{ - GEN_TEST(unsigned char); -} - - -TEST(MSGPACK, simple_buffer_short) -{ - GEN_TEST(short); -} - -TEST(MSGPACK, simple_buffer_int) -{ - GEN_TEST(int); -} - -TEST(MSGPACK, simple_buffer_long) -{ - GEN_TEST(long); -} - -TEST(MSGPACK, simple_buffer_long_long) -{ - GEN_TEST(long long); -} - -TEST(MSGPACK, simple_buffer_unsigned_short) -{ - GEN_TEST(unsigned short); -} - -TEST(MSGPACK, simple_buffer_unsigned_int) -{ - GEN_TEST(unsigned int); -} - -TEST(MSGPACK, simple_buffer_unsigned_long) -{ - GEN_TEST(unsigned long); -} - -TEST(MSGPACK, simple_buffer_unsigned_long_long) -{ - GEN_TEST(unsigned long long); -} - -TEST(MSGPACK, simple_buffer_uint8) -{ - GEN_TEST(uint8_t); -} - -TEST(MSGPACK, simple_buffer_uint16) -{ - GEN_TEST(uint16_t); -} - -TEST(MSGPACK, simple_buffer_uint32) -{ - GEN_TEST(uint32_t); -} - -TEST(MSGPACK, simple_buffer_uint64) -{ - GEN_TEST(uint64_t); -} - -TEST(MSGPACK, simple_buffer_int8) -{ - GEN_TEST(int8_t); -} - -TEST(MSGPACK, simple_buffer_int16) -{ - GEN_TEST(int16_t); -} - -TEST(MSGPACK, simple_buffer_int32) -{ - GEN_TEST(int32_t); -} - -TEST(MSGPACK, simple_buffer_int64) -{ - GEN_TEST(int64_t); -} - -TEST(MSGPACK, simple_buffer_float) -{ - vector v; - v.push_back(0.0); - v.push_back(-0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nanf("tag")); - v.push_back(1.0/0.0); // inf - v.push_back(-(1.0/0.0)); // -inf - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(drand48()); - v.push_back(-drand48()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - float val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - float val2 = ret.get().as(); - - if (std::isnan(val1)) - EXPECT_TRUE(std::isnan(val2)); - else if (std::isinf(val1)) - EXPECT_TRUE(std::isinf(val2)); - else - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -namespace { -template -struct TypePair { - typedef F float_type; - typedef I integer_type; -}; -} // namespace - -template -class IntegerToFloatingPointTest : public testing::Test { -}; -TYPED_TEST_CASE_P(IntegerToFloatingPointTest); - -TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) -{ - typedef typename TypeParam::float_type float_type; - typedef typename TypeParam::integer_type integer_type; - vector v; - v.push_back(0); - v.push_back(1); - if (numeric_limits::is_signed) v.push_back(-1); - else v.push_back(2); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(rand()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - integer_type val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - float_type val2 = ret.get().as(); - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -REGISTER_TYPED_TEST_CASE_P(IntegerToFloatingPointTest, - simple_buffer); - -typedef testing::Types, - TypePair, - TypePair, - TypePair > IntegerToFloatingPointTestTypes; -INSTANTIATE_TYPED_TEST_CASE_P(IntegerToFloatingPointTestInstance, - IntegerToFloatingPointTest, - IntegerToFloatingPointTestTypes); - -TEST(MSGPACK, simple_buffer_double) -{ - vector v; - v.push_back(0.0); - v.push_back(-0.0); - v.push_back(1.0); - v.push_back(-1.0); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); - v.push_back(nanf("tag")); - v.push_back(1.0/0.0); // inf - v.push_back(-(1.0/0.0)); // -inf - for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(drand48()); - v.push_back(-drand48()); - } - for (unsigned int i = 0; i < v.size() ; i++) { - msgpack::sbuffer sbuf; - double val1 = v[i]; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - double val2 = ret.get().as(); - - if (std::isnan(val1)) - EXPECT_TRUE(std::isnan(val2)); - else if (std::isinf(val1)) - EXPECT_TRUE(std::isinf(val2)); - else - EXPECT_TRUE(fabs(val2 - val1) <= kEPS); - } -} - -TEST(MSGPACK, simple_buffer_true) -{ - msgpack::sbuffer sbuf; - bool val1 = true; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - bool val2 = ret.get().as(); - EXPECT_EQ(val1, val2); -} - -TEST(MSGPACK, simple_buffer_false) -{ - msgpack::sbuffer sbuf; - bool val1 = false; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - bool val2 = ret.get().as(); - EXPECT_EQ(val1, val2); -} - -TEST(MSGPACK, simple_buffer_fixext1) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(1, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_EQ(2, ret.get().via.ext.data()[0]); -} - -TEST(MSGPACK, simple_buffer_fixext2) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3 }; - - packer.pack_ext(sizeof(buf), 0); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(2, ret.get().via.ext.size); - EXPECT_EQ(0, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext4) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3, 4, 5 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(4, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext8) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(8, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext16) -{ - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char const buf [] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 }; - - packer.pack_ext(sizeof(buf), 1); - packer.pack_ext_body(buf, sizeof(buf)); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(16, ret.get().via.ext.size); - EXPECT_EQ(1, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_1byte_0) -{ - std::size_t const size = 0; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - - packer.pack_ext(size, 77); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); -} - -TEST(MSGPACK, simple_buffer_fixext_1byte_255) -{ - std::size_t const size = 255; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_2byte_256) -{ - std::size_t const size = 256; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_2byte_65535) -{ - std::size_t const size = 65535; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -TEST(MSGPACK, simple_buffer_fixext_4byte_65536) -{ - std::size_t const size = 65536; - msgpack::sbuffer sbuf; - msgpack::packer packer(sbuf); - char buf[size]; - for (int i = 0; i != size; ++i) buf[i] = static_cast(i); - packer.pack_ext(sizeof(buf), 77); - packer.pack_ext_body(buf, sizeof(buf)); - - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(size, ret.get().via.ext.size); - EXPECT_EQ(77, ret.get().via.ext.type()); - EXPECT_TRUE( - std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data())); -} - -//----------------------------------------------------------------------------- - -// STL - -TEST(MSGPACK_STL, simple_buffer_string) -{ - for (unsigned int k = 0; k < kLoop; k++) { - string val1; - for (unsigned int i = 0; i < kElements; i++) - val1 += 'a' + rand() % 26; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::STR); - string val2 = ret.get().as(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(val1, val2); - } -} - -TEST(MSGPACK_STL, simple_buffer_cstring) -{ - for (unsigned int k = 0; k < kLoop; k++) { - string val1; - for (unsigned int i = 0; i < kElements; i++) - val1 += 'a' + rand() % 26; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1.c_str()); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::STR); - string val2 = ret.get().as(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(val1, val2); - } -} - -TEST(MSGPACK_STL, simple_buffer_vector) -{ - for (unsigned int k = 0; k < kLoop; k++) { - vector val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::ARRAY); - vector val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_vector_char) -{ - for (unsigned int k = 0; k < kLoop; k++) { - vector val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - EXPECT_EQ(ret.get().type, msgpack::type::BIN); - vector val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_deque) -{ - for (unsigned int k = 0; k < kLoop; k++) { - deque val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - deque val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_list) -{ - for (unsigned int k = 0; k < kLoop; k++) { - list val1; - for (unsigned int i = 0; i < kElements; i++) - val1.push_back(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - list val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin())); - } -} - -TEST(MSGPACK_STL, simple_buffer_pair) -{ - for (unsigned int k = 0; k < kLoop; k++) { - pair val1 = make_pair(rand(), rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - pair val2 = ret.get().as >(); - EXPECT_EQ(val1.first, val2.first); - EXPECT_EQ(val1.second, val2.second); - } -} - -TEST(MSGPACK_STL, simple_buffer_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - multimap val2 = ret.get().as >(); - - vector > v1, v2; - multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} - -TEST(MSGPACK_STL, simple_buffer_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - multiset val2 = ret.get().as >(); - - vector v1, v2; - multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} - -// TR1 - -#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP -#include -#include "msgpack/adaptor/tr1/unordered_map.hpp" -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_map::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) { - EXPECT_TRUE(val2.find(it->first) != val2.end()); - EXPECT_EQ(it->second, val2.find(it->first)->second); - } - } -} - -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_multimap val2 = ret.get().as >(); - - vector > v1, v2; - tr1::unordered_multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_SET -#include -#include "msgpack/adaptor/tr1/unordered_set.hpp" -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - tr1::unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } -} - -TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - tr1::unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - tr1::unordered_multiset val2 = ret.get().as >(); - - vector v1, v2; - tr1::unordered_multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_UNOURDERED_MAP -#include -#include "msgpack/adaptor/tr1/unordered_map.hpp" -TEST(MSGPACK_TR1, simple_buffer_unordered_map) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_map val1; - for (unsigned int i = 0; i < kElements; i++) - val1[rand()] = rand(); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_map val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - unordered_map::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) { - EXPECT_TRUE(val2.find(it->first) != val2.end()); - EXPECT_EQ(it->second, val2.find(it->first)->second); - } - } -} - -TEST(MSGPACK_TR1, simple_buffer_unordered_multimap) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multimap val1; - for (unsigned int i = 0; i < kElements; i++) { - int i1 = rand(); - val1.insert(make_pair(i1, rand())); - val1.insert(make_pair(i1, rand())); - } - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multimap val2 = ret.get().as >(); - - vector > v1, v2; - unordered_multimap::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(make_pair(it->first, it->second)); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(make_pair(it->first, it->second)); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - -#ifdef MSGPACK_HAS_STD_UNOURDERED_SET -#include -#include "msgpack/adaptor/tr1/unordered_set.hpp" -TEST(MSGPACK_TR1, simple_buffer_unordered_set) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_set val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_set val2 = ret.get().as >(); - EXPECT_EQ(val1.size(), val2.size()); - unordered_set::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - EXPECT_TRUE(val2.find(*it) != val2.end()); - } -} - -TEST(MSGPACK_TR1, simple_buffer_unordered_multiset) -{ - for (unsigned int k = 0; k < kLoop; k++) { - unordered_multiset val1; - for (unsigned int i = 0; i < kElements; i++) - val1.insert(rand()); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - unordered_multiset val2 = ret.get().as >(); - - vector v1, v2; - unordered_multiset::const_iterator it; - for (it = val1.begin(); it != val1.end(); ++it) - v1.push_back(*it); - for (it = val2.begin(); it != val2.end(); ++it) - v2.push_back(*it); - EXPECT_EQ(val1.size(), val2.size()); - EXPECT_EQ(v1.size(), v2.size()); - sort(v1.begin(), v1.end()); - sort(v2.begin(), v2.end()); - EXPECT_TRUE(v1 == v2); - } -} -#endif - - -// User-Defined Structures - -class TestClass -{ -public: - TestClass() : i(0), s("kzk") {} - int i; - string s; - MSGPACK_DEFINE(i, s); -}; - -TEST(MSGPACK_USER_DEFINED, simple_buffer_class) -{ - for (unsigned int k = 0; k < kLoop; k++) { - TestClass val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - TestClass val2 = ret.get().as(); - EXPECT_EQ(val1.i, val2.i); - EXPECT_EQ(val1.s, val2.s); - } -} - -class TestClass2 -{ -public: - TestClass2() : i(0), s("kzk") { - for (unsigned int i = 0; i < kElements; i++) - v.push_back(rand()); - } - int i; - string s; - vector v; - MSGPACK_DEFINE(i, s, v); -}; - -TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new) -{ - for (unsigned int k = 0; k < kLoop; k++) { - TestClass val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - TestClass2 val2 = ret.get().as(); - EXPECT_EQ(val1.i, val2.i); - EXPECT_EQ(val1.s, val2.s); - EXPECT_FALSE(val2.s.empty()); - } -} - -TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old) -{ - for (unsigned int k = 0; k < kLoop; k++) { - TestClass2 val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - TestClass val2 = ret.get().as(); - EXPECT_EQ(val1.i, val2.i); - EXPECT_EQ(val1.s, val2.s); - EXPECT_FALSE(val2.s.empty()); - } -} - -class TestEnumMemberClass -{ -public: - TestEnumMemberClass() - : t1(STATE_A), t2(STATE_B), t3(STATE_C) {} - - enum TestEnumType { - STATE_INVALID = 0, - STATE_A = 1, - STATE_B = 2, - STATE_C = 3 - }; - TestEnumType t1; - TestEnumType t2; - TestEnumType t3; - - MSGPACK_DEFINE(t1, t2, t3); -}; - -MSGPACK_ADD_ENUM(TestEnumMemberClass::TestEnumType); - -TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member) -{ - TestEnumMemberClass val1; - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - TestEnumMemberClass val2 = ret.get().as(); - EXPECT_EQ(val1.t1, val2.t1); - EXPECT_EQ(val1.t2, val2.t2); - EXPECT_EQ(val1.t3, val2.t3); -} - -class TestUnionMemberClass -{ -public: - TestUnionMemberClass() {} - TestUnionMemberClass(double f) { - is_double = true; - value.f = f; - } - TestUnionMemberClass(int i) { - is_double = false; - value.i = i; - } - - union { - double f; - int i; - } value; - bool is_double; - - template - void msgpack_pack(Packer& pk) const - { - if (is_double) - pk.pack(msgpack::type::tuple(true, value.f)); - else - pk.pack(msgpack::type::tuple(false, value.i)); - } - - void msgpack_unpack(msgpack::object o) - { - msgpack::type::tuple tuple; - o.convert(&tuple); - - is_double = tuple.get<0>(); - if (is_double) - tuple.get<1>().convert(&value.f); - else - tuple.get<1>().convert(&value.i); - } -}; - -TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member) -{ - { - // double - TestUnionMemberClass val1(1.0); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - TestUnionMemberClass val2 = ret.get().as(); - EXPECT_EQ(val1.is_double, val2.is_double); - EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS); - } - { - // int - TestUnionMemberClass val1(1); - msgpack::sbuffer sbuf; - msgpack::pack(sbuf, val1); - msgpack::unpacked ret; - msgpack::unpack(ret, sbuf.data(), sbuf.size()); - TestUnionMemberClass val2 = ret.get().as(); - EXPECT_EQ(val1.is_double, val2.is_double); - EXPECT_EQ(val1.value.i, 1); - EXPECT_EQ(val1.value.i, val2.value.i); - } -} - -//----------------------------------------------------------------------------- - -#define GEN_TEST_VREF(test_type, vbuf) \ - do { \ - vector v; \ - v.push_back(0); \ - for (unsigned int i = 0; i < v.size(); i++) { \ - test_type val1 = v[i]; \ - msgpack::pack(vbuf, val1); \ - msgpack::sbuffer sbuf; \ - const struct iovec* cur = vbuf.vector(); \ - const struct iovec* end = cur + vbuf.vector_size(); \ - for(; cur != end; ++cur) \ - sbuf.write((const char*)cur->iov_base, cur->iov_len); \ - msgpack::unpacked ret; \ - msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ - test_type val2 = ret.get().as(); \ - EXPECT_EQ(val1, val2); \ - } \ - } while(0); - -TEST(MSGPACK, vrefbuffer_char) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_signed_char) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(signed char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_char) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_short) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_long_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_short) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_int) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_unsigned_long_long) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(unsigned long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint8) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint16) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint32) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_uint64) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(uint64_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int8) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int16) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int32) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_int64) -{ - msgpack::vrefbuffer vbuf; - GEN_TEST_VREF(int64_t, vbuf); -} - -// small ref_size and chunk_size -TEST(MSGPACK, vrefbuffer_small_char) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_signed_char) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(signed char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_char) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned char, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_short) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_long_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_short) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned short, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_int) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned int, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_unsigned_long_long) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(unsigned long long, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint8) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint16) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint32) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_uint64) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(uint64_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int8) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int8_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int16) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int16_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int32) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int32_t, vbuf); -} - -TEST(MSGPACK, vrefbuffer_small_int64) -{ - msgpack::vrefbuffer vbuf(0, 0); - GEN_TEST_VREF(int64_t, vbuf); -} - -//----------------------------------------------------------------------------- - -#define GEN_TEST_STREAM(test_type) \ - for (unsigned int k = 0; k < kLoop; k++) { \ - msgpack::sbuffer sbuf; \ - msgpack::packer pk(sbuf); \ - typedef std::vector vec_type; \ - vec_type vec; \ - for(unsigned int i = 0; i < rand() % kLoop; ++i) { \ - vec_type::value_type r = rand(); \ - vec.push_back(r); \ - pk.pack(r); \ - } \ - msgpack::unpacker pac; \ - vec_type::const_iterator it = vec.begin(); \ - const char *p = sbuf.data(); \ - const char * const pend = p + sbuf.size(); \ - while (p < pend) { \ - const size_t sz = std::min(pend - p, rand() % 128); \ - pac.reserve_buffer(sz); \ - memcpy(pac.buffer(), p, sz); \ - pac.buffer_consumed(sz); \ - msgpack::unpacked result; \ - while (pac.next(result)) { \ - if (it == vec.end()) goto out; \ - msgpack::object obj = result.get(); \ - vec_type::value_type val; \ - obj.convert(&val); \ - EXPECT_EQ(*it, val); \ - ++it; \ - } \ - p += sz; \ - } \ - out: \ - ; \ - } - -TEST(MSGPACK, stream_char) -{ - GEN_TEST_STREAM(char); -} - -TEST(MSGPACK, stream_signed_char) -{ - GEN_TEST_STREAM(signed char); -} - -TEST(MSGPACK, stream_unsigned_char) -{ - GEN_TEST_STREAM(unsigned char); -} - -TEST(MSGPACK, stream_short) -{ - GEN_TEST_STREAM(short); -} - -TEST(MSGPACK, stream_int) -{ - GEN_TEST_STREAM(int); -} - -TEST(MSGPACK, stream_long) -{ - GEN_TEST_STREAM(long); -} - -TEST(MSGPACK, stream_long_long) -{ - GEN_TEST_STREAM(long long); -} - -TEST(MSGPACK, stream_unsigned_short) -{ - GEN_TEST_STREAM(unsigned short); -} - -TEST(MSGPACK, stream_unsigned_int) -{ - GEN_TEST_STREAM(unsigned int); -} - -TEST(MSGPACK, stream_unsigned_long) -{ - GEN_TEST_STREAM(unsigned long); -} - -TEST(MSGPACK, stream_unsigned_long_long) -{ - GEN_TEST_STREAM(unsigned long long); -} - -TEST(MSGPACK, stream_uint8) -{ - GEN_TEST_STREAM(uint8_t); -} - -TEST(MSGPACK, stream_uint16) -{ - GEN_TEST_STREAM(uint16_t); -} - -TEST(MSGPACK, stream_uint32) -{ - GEN_TEST_STREAM(uint32_t); -} - -TEST(MSGPACK, stream_uint64) -{ - GEN_TEST_STREAM(uint64_t); -} - -TEST(MSGPACK, stream_int8) -{ - GEN_TEST_STREAM(int8_t); -} - -TEST(MSGPACK, stream_int16) -{ - GEN_TEST_STREAM(int16_t); -} - -TEST(MSGPACK, stream_int32) -{ - GEN_TEST_STREAM(int32_t); -} - -TEST(MSGPACK, stream_int64) -{ - GEN_TEST_STREAM(int64_t); -} diff --git a/test/msgpack_vref.cpp b/test/msgpack_vref.cpp new file mode 100644 index 00000000..a66179b1 --- /dev/null +++ b/test/msgpack_vref.cpp @@ -0,0 +1,270 @@ +#include "msgpack.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +using namespace std; + +const unsigned int kLoop = 10000; +const unsigned int kElements = 100; +const double kEPS = 1e-10; + +#define GEN_TEST_VREF(test_type, vbuf) \ + do { \ + vector v; \ + v.push_back(0); \ + for (unsigned int i = 0; i < v.size(); i++) { \ + test_type val1 = v[i]; \ + msgpack::pack(vbuf, val1); \ + msgpack::sbuffer sbuf; \ + const struct iovec* cur = vbuf.vector(); \ + const struct iovec* end = cur + vbuf.vector_size(); \ + for(; cur != end; ++cur) \ + sbuf.write((const char*)cur->iov_base, cur->iov_len); \ + msgpack::unpacked ret; \ + msgpack::unpack(ret, sbuf.data(), sbuf.size()); \ + test_type val2 = ret.get().as(); \ + EXPECT_EQ(val1, val2); \ + } \ + } while(0); + +TEST(MSGPACK, vrefbuffer_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_signed_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(signed char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_char) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_short) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_long_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_short) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_int) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_unsigned_long_long) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(unsigned long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint8) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint16) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint32) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_uint64) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(uint64_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int8) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int16) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int32) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_int64) +{ + msgpack::vrefbuffer vbuf; + GEN_TEST_VREF(int64_t, vbuf); +} + +// small ref_size and chunk_size +TEST(MSGPACK, vrefbuffer_small_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_signed_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(signed char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_char) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned char, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_short) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned short, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_int) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned int, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_unsigned_long_long) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(unsigned long long, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_uint64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(uint64_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int8) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int8_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int16) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int16_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int32) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int32_t, vbuf); +} + +TEST(MSGPACK, vrefbuffer_small_int64) +{ + msgpack::vrefbuffer vbuf(0, 0); + GEN_TEST_VREF(int64_t, vbuf); +} diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp index cb49b8b3..38182f0c 100644 --- a/test/object_with_zone.cpp +++ b/test/object_with_zone.cpp @@ -8,7 +8,7 @@ using namespace std; -const unsigned int kLoop = 10000; +const unsigned int kLoop = 1000; const unsigned int kElements = 100; const double kEPS = 1e-10; From dd4043a61682c2cead07d0c8024725e2b86df0f7 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 9 Sep 2014 14:29:10 +0900 Subject: [PATCH 138/153] Removed unused variables. --- test/msgpack_cpp11.cpp | 1 - test/msgpack_stream.cpp | 2 -- test/msgpack_vref.cpp | 4 ---- 3 files changed, 7 deletions(-) diff --git a/test/msgpack_cpp11.cpp b/test/msgpack_cpp11.cpp index d06b184c..26e033df 100644 --- a/test/msgpack_cpp11.cpp +++ b/test/msgpack_cpp11.cpp @@ -10,7 +10,6 @@ using namespace std; const unsigned int kLoop = 10000; const unsigned int kElements = 100; -const double kEPS = 1e-10; #if !defined(MSGPACK_USE_CPP03) diff --git a/test/msgpack_stream.cpp b/test/msgpack_stream.cpp index 2f4be819..a317cca2 100644 --- a/test/msgpack_stream.cpp +++ b/test/msgpack_stream.cpp @@ -18,8 +18,6 @@ using namespace std; const unsigned int kLoop = 1000; -const unsigned int kElements = 100; -const double kEPS = 1e-10; #define GEN_TEST_STREAM(test_type) \ diff --git a/test/msgpack_vref.cpp b/test/msgpack_vref.cpp index a66179b1..845fe7c9 100644 --- a/test/msgpack_vref.cpp +++ b/test/msgpack_vref.cpp @@ -17,10 +17,6 @@ using namespace std; -const unsigned int kLoop = 10000; -const unsigned int kElements = 100; -const double kEPS = 1e-10; - #define GEN_TEST_VREF(test_type, vbuf) \ do { \ vector v; \ From 6e810df2a4bb4d1680826542592a1e5f7be24f75 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 14 Sep 2014 20:50:57 +0900 Subject: [PATCH 139/153] Added zero size tuple support. --- include/msgpack/adaptor/cpp11/tuple.hpp | 25 +++++++++++++++++ .../adaptor/detail/cpp11_msgpack_tuple.hpp | 24 +++++++++++++++++ test/msgpack_container.cpp | 27 +++++++++++++++++++ test/msgpack_cpp11.cpp | 11 ++++++++ test/object_with_zone.cpp | 18 +++++++++++++ 5 files changed, 105 insertions(+) diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index e29a0e17..463c11a3 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -45,6 +45,15 @@ struct StdTuplePacker { } }; +template +struct StdTuplePacker { + static void pack ( + packer&, + const Tuple&) { + } +}; + + template const packer& operator<< ( packer& o, @@ -75,6 +84,14 @@ struct StdTupleConverter { } }; +template +struct StdTupleConverter { + static void convert ( + object const&, + Tuple&) { + } +}; + template object const& operator>> ( object const& o, @@ -105,6 +122,14 @@ struct StdTupleToObjectWithZone { } }; +template +struct StdTupleToObjectWithZone { + static void convert ( + object::with_zone&, + const Tuple&) { + } +}; + template inline void operator<< ( object::with_zone& o, diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 4dee4602..8b5aa607 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -109,6 +109,14 @@ struct MsgpackTuplePacker { } }; +template +struct MsgpackTuplePacker { + static void pack ( + packer&, + const Tuple&) { + } +}; + template const packer& operator<< ( packer& o, @@ -139,6 +147,14 @@ struct MsgpackTupleConverter { } }; +template +struct MsgpackTupleConverter { + static void convert ( + object const&, + Tuple&) { + } +}; + template object const& operator>> ( object const& o, @@ -169,6 +185,14 @@ struct MsgpackTupleToObjectWithZone { } }; +template +struct MsgpackTupleToObjectWithZone { + static void convert ( + object::with_zone&, + const Tuple&) { + } +}; + template inline void operator<< ( object::with_zone& o, diff --git a/test/msgpack_container.cpp b/test/msgpack_container.cpp index 5b8accf0..febef394 100644 --- a/test/msgpack_container.cpp +++ b/test/msgpack_container.cpp @@ -188,6 +188,33 @@ TEST(MSGPACK_STL, simple_buffer_multiset) } } +TEST(MSGPACK_TUPLE, simple_tuple) +{ + msgpack::sbuffer sbuf; + msgpack::type::tuple val1(true, "kzk", 12.3); + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + msgpack::type::tuple val2 + = ret.get().as >(); + EXPECT_EQ(ret.get().via.array.size, 3); + EXPECT_EQ(val1.get<0>(), val2.get<0>()); + EXPECT_EQ(val1.get<1>(), val2.get<1>()); + EXPECT_EQ(val1.get<2>(), val2.get<2>()); +} + +TEST(MSGPACK_TUPLE, simple_tuple_empty) +{ + msgpack::sbuffer sbuf; + msgpack::type::tuple<> val1; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + ret.get().as >(); + EXPECT_EQ(ret.get().via.array.size, 0); +} + + // TR1 #ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP diff --git a/test/msgpack_cpp11.cpp b/test/msgpack_cpp11.cpp index 26e033df..2d48043e 100644 --- a/test/msgpack_cpp11.cpp +++ b/test/msgpack_cpp11.cpp @@ -26,6 +26,17 @@ TEST(MSGPACK_CPP11, simple_tuple) EXPECT_EQ(val1, val2); } +TEST(MSGPACK_CPP11, simple_tuple_empty) +{ + msgpack::sbuffer sbuf; + std::tuple<> val1; + msgpack::pack(sbuf, val1); + msgpack::unpacked ret; + msgpack::unpack(ret, sbuf.data(), sbuf.size()); + std::tuple<> val2 = ret.get().as >(); + EXPECT_EQ(val1, val2); +} + TEST(MSGPACK_CPP11, simple_array) { for (unsigned int k = 0; k < kLoop; k++) { diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp index 38182f0c..34349941 100644 --- a/test/object_with_zone.cpp +++ b/test/object_with_zone.cpp @@ -387,6 +387,15 @@ TEST(object_with_zone, msgpack_tuple) EXPECT_EQ(msgpack::type::get<0>(obj.as()), 1); } +TEST(object_with_zone, msgpack_tuple_empty) +{ + typedef msgpack::type::tuple<> test_t; + test_t v; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.via.array.size, 0); +} + // TR1 #ifdef MSGPACK_HAS_STD_TR1_UNOURDERED_MAP @@ -680,4 +689,13 @@ TEST(object_with_zone, tuple) EXPECT_EQ(obj.as(), v); } +TEST(object_with_zone, tuple_empty) +{ + typedef tuple<> test_t; + test_t v; + msgpack::zone z; + msgpack::object obj(v, z); + EXPECT_EQ(obj.as(), v); +} + #endif From 03ed30ce036d34016bdcf2c5c952c0424240faa0 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 15 Sep 2014 18:16:37 +0900 Subject: [PATCH 140/153] Fixed https://github.com/msgpack/msgpack-c/issues/76 Clear deserialized target containers. As the result of this fix, all containers' deserialized behaviors become consistent. --- include/msgpack/adaptor/map.hpp | 12 ++++++++---- include/msgpack/adaptor/set.hpp | 8 ++++++-- include/msgpack/adaptor/tr1/unordered_map.hpp | 8 ++++++-- include/msgpack/adaptor/tr1/unordered_set.hpp | 8 ++++++-- 4 files changed, 26 insertions(+), 10 deletions(-) diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index 5cf61762..4f2e0af0 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -99,18 +99,20 @@ inline object const& operator>> (object const& o, std::map& v) if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::map tmp; for(; p != pend; ++p) { K key; p->key.convert(key); - typename std::map::iterator it(v.lower_bound(key)); - if(it != v.end() && !(key < it->first)) { + typename std::map::iterator it(tmp.lower_bound(key)); + if(it != tmp.end() && !(key < it->first)) { p->val.convert(it->second); } else { V val; p->val.convert(val); - v.insert(it, std::pair(key, val)); + tmp.insert(it, std::pair(key, val)); } } + tmp.swap(v); return o; } @@ -155,12 +157,14 @@ inline object const& operator>> (object const& o, std::multimap& v) if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); object_kv* const pend(o.via.map.ptr + o.via.map.size); + std::multimap tmp; for(; p != pend; ++p) { std::pair value; p->key.convert(value.first); p->val.convert(value.second); - v.insert(value); + tmp.insert(value); } + tmp.swap(v); return o; } diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index f949944e..fa2b5657 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -30,10 +30,12 @@ inline object const& operator>> (object const& o, std::set& v) if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; object* const pbegin = o.via.array.ptr; + std::set tmp; while(p > pbegin) { --p; - v.insert(p->as()); + tmp.insert(p->as()); } + tmp.swap(v); return o; } @@ -76,10 +78,12 @@ inline object const& operator>> (object const& o, std::multiset& v) if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; object* const pbegin = o.via.array.ptr; + std::multiset tmp; while(p > pbegin) { --p; - v.insert(p->as()); + tmp.insert(p->as()); } + tmp.swap(v); return o; } diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 6495fa9b..7e6ea497 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -49,11 +49,13 @@ inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); object_kv* const pend(o.via.map.ptr + o.via.map.size); + MSGPACK_STD_TR1::unordered_map tmp; for(; p != pend; ++p) { K key; p->key.convert(key); - p->val.convert(v[key]); + p->val.convert(tmp[key]); } + tmp.swap(v); return o; } @@ -98,12 +100,14 @@ inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_mul if(o.type != type::MAP) { throw type_error(); } object_kv* p(o.via.map.ptr); object_kv* const pend(o.via.map.ptr + o.via.map.size); + MSGPACK_STD_TR1::unordered_multimap tmp; for(; p != pend; ++p) { std::pair value; p->key.convert(value.first); p->val.convert(value.second); - v.insert(value); + tmp.insert(value); } + tmp.swap(v); return o; } diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index e6086c09..384e2fac 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -48,10 +48,12 @@ inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; object* const pbegin = o.via.array.ptr; + MSGPACK_STD_TR1::unordered_set tmp; while(p > pbegin) { --p; - v.insert(p->as()); + tmp.insert(p->as()); } + tmp.swap(v); return o; } @@ -94,10 +96,12 @@ inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_mul if(o.type != type::ARRAY) { throw type_error(); } object* p = o.via.array.ptr + o.via.array.size; object* const pbegin = o.via.array.ptr; + MSGPACK_STD_TR1::unordered_multiset tmp; while(p > pbegin) { --p; - v.insert(p->as()); + tmp.insert(p->as()); } + tmp.swap(v); return o; } From 4fcb4777f3e42ca0b099eb4f12f84d8c18a1ac3b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 15 Sep 2014 22:33:23 +0900 Subject: [PATCH 141/153] Added additional unpack() APIs to support C++11 style programming. --- include/msgpack/unpack.hpp | 73 ++++++++++++ test/CMakeLists.txt | 1 + test/Makefile.am | 3 + test/pack_unpack.cpp | 120 ++++++++++++++++++- test/reference_cpp11.cpp | 232 +++++++++++++++++++++++++++++++++++++ 5 files changed, 424 insertions(+), 5 deletions(-) create mode 100644 test/reference_cpp11.cpp diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index d6199145..e7be9f20 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -964,6 +964,24 @@ private: unpacker& operator=(const unpacker&); }; +#if !defined(MSGPACK_USE_CPP03) + +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline unpacked unpack( + const char* data, std::size_t len, bool& referenced, + unpack_reference_func f = nullptr, void* user_data = nullptr); +inline unpacked unpack( + const char* data, std::size_t len, + unpack_reference_func f = nullptr, void* user_data = nullptr); + +#endif // !defined(MSGPACK_USE_CPP03) + + inline void unpack(unpacked& result, const char* data, std::size_t len, std::size_t& off, bool& referenced, unpack_reference_func f = nullptr, void* user_data = nullptr); @@ -1312,6 +1330,61 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off, } // detail // reference version + +#if !defined(MSGPACK_USE_CPP03) + +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, bool& referenced, + unpack_reference_func f, void* user_data) +{ + object obj; + msgpack::unique_ptr z(new zone); + referenced = false; + unpack_return ret = detail::unpack_imp( + data, len, off, *z, obj, referenced, f, user_data); + + switch(ret) { + case UNPACK_SUCCESS: + return unpacked(obj, msgpack::move(z)); + case UNPACK_EXTRA_BYTES: + return unpacked(obj, msgpack::move(z)); + case UNPACK_CONTINUE: + throw unpack_error("insufficient bytes"); + case UNPACK_PARSE_ERROR: + default: + throw unpack_error("parse error"); + } + return unpacked(); +} + +inline unpacked unpack( + const char* data, std::size_t len, std::size_t& off, + unpack_reference_func f, void* user_data) +{ + bool referenced; + return unpack(data, len, off, referenced, f, user_data); +} + +inline unpacked unpack( + const char* data, std::size_t len, bool& referenced, + unpack_reference_func f, void* user_data) +{ + std::size_t off = 0; + return unpack(data, len, off, referenced, f, user_data); +} + +inline unpacked unpack( + const char* data, std::size_t len, + unpack_reference_func f, void* user_data) +{ + bool referenced; + std::size_t off = 0; + return unpack(data, len, off, referenced, f, user_data); +} + +#endif // !defined(MSGPACK_USE_CPP03) + + inline void unpack(unpacked& result, const char* data, std::size_t len, std::size_t& off, bool& referenced, unpack_reference_func f, void* user_data) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 3c971a29..59bf41d8 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -33,6 +33,7 @@ LIST (APPEND check_PROGRAMS IF (MSGPACK_CXX11) LIST (APPEND check_PROGRAMS msgpack_cpp11.cpp + reference_cpp11.cpp ) ENDIF () diff --git a/test/Makefile.am b/test/Makefile.am index 35859b3a..c12c56d2 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -23,6 +23,7 @@ check_PROGRAMS = \ msgpack_stream \ msgpack_vref \ msgpack_cpp11 \ + reference_cpp11 \ reference TESTS = $(check_PROGRAMS) @@ -70,4 +71,6 @@ msgpack_cpp11_SOURCES = msgpack_cpp11.cpp reference_SOURCES = reference.cpp +reference_cpp11_SOURCES = reference_cpp11.cpp + EXTRA_DIST = cases.mpac cases_compact.mpac diff --git a/test/pack_unpack.cpp b/test/pack_unpack.cpp index b95bccde..da635683 100644 --- a/test/pack_unpack.cpp +++ b/test/pack_unpack.cpp @@ -49,7 +49,58 @@ TEST(pack, myclass) msgpack::pack(sbuf, m); } -TEST(unpack, int_no_offset) + +#if !defined(MSGPACK_USE_CPP03) + +TEST(unpack, int_ret_no_offset_no_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size()); + EXPECT_EQ(1, msg.get().as()); +} + +TEST(unpack, int_ret_offset_no_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + std::size_t off = 0; + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), off); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); +} + +TEST(unpack, int_ret_no_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + bool referenced; + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); +} + +TEST(unpack, int_ret_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + std::size_t off = 0; + bool referenced; + + msgpack::unpacked msg = msgpack::unpack(sbuf.data(), sbuf.size(), off, referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); + EXPECT_EQ(off, sbuf.size()); +} + +#endif // !defined(MSGPACK_USE_CPP03) + + +TEST(unpack, int_no_offset_no_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -59,7 +110,7 @@ TEST(unpack, int_no_offset) EXPECT_EQ(1, msg.get().as()); } -TEST(unpack, int_offset) +TEST(unpack, int_offset_no_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -72,7 +123,34 @@ TEST(unpack, int_offset) EXPECT_EQ(off, sbuf.size()); } -TEST(unpack, int_pointer) +TEST(unpack, int_no_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + bool referenced; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); +} + +TEST(unpack, int_offset_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + std::size_t off = 0; + bool referenced; + + msgpack::unpack(msg, sbuf.data(), sbuf.size(), off, referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); + EXPECT_EQ(off, sbuf.size()); +} + + +TEST(unpack, int_pointer_off_no_ref) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); @@ -86,17 +164,49 @@ TEST(unpack, int_pointer) EXPECT_EQ(off, sbuf.size()); } -TEST(unpack, int_null_pointer) +TEST(unpack, int_pointer_off_no_ref_explicit) { msgpack::sbuffer sbuf; msgpack::pack(sbuf, 1); msgpack::unpacked msg; + std::size_t off = 0; + // obsolete - msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr); + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off, nullptr); EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); } +TEST(unpack, int_pointer_no_off_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + bool referenced; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr, &referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(false, referenced); +} + +TEST(unpack, int_pointer_off_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + msgpack::unpacked msg; + bool referenced; + std::size_t off = 0; + + // obsolete + msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off, &referenced); + EXPECT_EQ(1, msg.get().as()); + EXPECT_EQ(off, sbuf.size()); + EXPECT_EQ(false, referenced); +} + + TEST(unpack, int_default_null_pointer) { msgpack::sbuffer sbuf; diff --git a/test/reference_cpp11.cpp b/test/reference_cpp11.cpp new file mode 100644 index 00000000..e4112024 --- /dev/null +++ b/test/reference_cpp11.cpp @@ -0,0 +1,232 @@ +#include +#include + +#if !defined(MSGPACK_USE_CPP03) + +TEST(reference, unpack_int) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_string) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_bin) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_ext) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced); + EXPECT_FALSE(referenced); +} + +bool never_called(msgpack::type::object_type, std::size_t, void*) +{ + EXPECT_TRUE(false); + return false; +} + +bool always_reference(msgpack::type::object_type, std::size_t, void*) +{ + return true; +} + +TEST(reference, unpack_int_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called); + EXPECT_FALSE(referenced); +} + +TEST(reference, unpack_string_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("abcdefg")); + bool referenced; + + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpack_bin_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +TEST(reference, unpack_ext_ref) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 2 }; + + packer.pack_ext(sizeof(buf), 1); + packer.pack_ext_body(buf, sizeof(buf)); + bool referenced; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, always_reference); + EXPECT_TRUE(referenced); +} + +static void* s_p; + +bool sized_reference(msgpack::type::object_type t, std::size_t s, void* p) +{ + s_p = p; + switch (t) { + case msgpack::type::STR: + if (s >= 5) return true; + break; + case msgpack::type::BIN: + if (s >= 6) return true; + break; + case msgpack::type::EXT: + if (s >= 7) return true; + break; + default: + EXPECT_TRUE(false); + } + return false; +} + +TEST(reference, unpack_int_sized_ref) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, 1); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, never_called, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(nullptr, s_p); +} + +TEST(reference, unpack_string_sized_ref_4) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("1234")); + + bool referenced; + s_p = nullptr; + // the last argument sbuf is any pointer as a user data. + // That is stored to s_p in sized_reference + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + // compare the passed argument with stored s_p. + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_string_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::pack(sbuf, std::string("12345")); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + + +TEST(reference, unpack_bin_sized_ref_5) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_bin_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char c[] = { 1, 2, 3, 4, 5, 6 }; + packer.pack_bin(sizeof(c)); + packer.pack_bin_body(c, sizeof(c)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_6) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5 }; + + packer.pack_ext(sizeof(buf), 1); // 5 + 1(type) = 6 + packer.pack_ext_body(buf, sizeof(buf)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_FALSE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +TEST(reference, unpack_ext_sized_ref_7) +{ + msgpack::sbuffer sbuf; + msgpack::packer packer(sbuf); + char const buf [] = { 1, 2, 3, 4, 5, 6 }; + + packer.pack_ext(sizeof(buf), 1); // 6 + 1(type) = 7 + packer.pack_ext_body(buf, sizeof(buf)); + + bool referenced; + s_p = nullptr; + msgpack::unpacked ret = msgpack::unpack(sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf); + EXPECT_TRUE(referenced); + EXPECT_EQ(&sbuf, s_p); +} + +#endif // !defined(MSGPACK_USE_CPP03) From d6122b4a18cbc9829cc1dbebf72890fcab311ff8 Mon Sep 17 00:00:00 2001 From: Thiago de Arruda Date: Mon, 15 Sep 2014 15:26:42 -0300 Subject: [PATCH 142/153] Fix size packing/unpacking for EXT 8/16/32 For EXT 8/16/32, the "size" field was being incremented by 1 to account for the type field, but according to the specification the size should only consider the length of the data field. --- include/msgpack/pack_template.h | 1 - include/msgpack/unpack_template.h | 6 +++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/include/msgpack/pack_template.h b/include/msgpack/pack_template.h index 9426a217..fc47619f 100644 --- a/include/msgpack/pack_template.h +++ b/include/msgpack/pack_template.h @@ -841,7 +841,6 @@ msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type) msgpack_pack_append_buffer(x, buf, 2); } break; default: - l += 1; if(l < 256) { char buf[3]; buf[0] = 0xc7; diff --git a/include/msgpack/unpack_template.h b/include/msgpack/unpack_template.h index 7e50692f..28ceb9e4 100644 --- a/include/msgpack/unpack_template.h +++ b/include/msgpack/unpack_template.h @@ -324,7 +324,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c case CS_BIN_8: again_fixed_trail_if_zero(ACS_BIN_VALUE, *(uint8_t*)n, _bin_zero); case CS_EXT_8: - again_fixed_trail_if_zero(ACS_EXT_VALUE, *(uint8_t*)n, _ext_zero); + again_fixed_trail_if_zero(ACS_EXT_VALUE, (*(uint8_t*)n) + 1, _ext_zero); case CS_STR_16:{ uint16_t tmp; _msgpack_load16(uint16_t,n,&tmp); @@ -338,7 +338,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c case CS_EXT_16:{ uint16_t tmp; _msgpack_load16(uint16_t,n,&tmp); - again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp, _ext_zero); + again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp + 1, _ext_zero); } case CS_STR_32:{ uint32_t tmp; @@ -353,7 +353,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c case CS_EXT_32:{ uint32_t tmp; _msgpack_load32(uint32_t,n,&tmp); - again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp, _ext_zero); + again_fixed_trail_if_zero(ACS_EXT_VALUE, tmp + 1, _ext_zero); } case ACS_STR_VALUE: _str_zero: From 3ddeb08e6e33647017bc6c4599e87231e99476c9 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 12 Oct 2014 22:48:15 +0900 Subject: [PATCH 143/153] Added API versioning. --- CMakeLists.txt | 1 + erb/cpp03_define.hpp.erb | 6 ++ erb/cpp03_msgpack_tuple.hpp.erb | 5 ++ erb/cpp03_zone.hpp.erb | 5 ++ include/msgpack/adaptor/bool.hpp | 4 + include/msgpack/adaptor/char_ptr.hpp | 4 + include/msgpack/adaptor/cpp11/array.hpp | 5 ++ include/msgpack/adaptor/cpp11/array_char.hpp | 5 ++ .../msgpack/adaptor/cpp11/forward_list.hpp | 5 ++ include/msgpack/adaptor/cpp11/tuple.hpp | 8 +- include/msgpack/adaptor/deque.hpp | 3 + .../msgpack/adaptor/detail/cpp03_define.hpp | 6 ++ .../adaptor/detail/cpp03_msgpack_tuple.hpp | 5 ++ .../msgpack/adaptor/detail/cpp11_define.hpp | 6 ++ .../adaptor/detail/cpp11_msgpack_tuple.hpp | 8 +- include/msgpack/adaptor/fixint.hpp | 5 ++ include/msgpack/adaptor/float.hpp | 4 + include/msgpack/adaptor/int.hpp | 4 + include/msgpack/adaptor/list.hpp | 3 + include/msgpack/adaptor/map.hpp | 3 + include/msgpack/adaptor/nil.hpp | 4 + include/msgpack/adaptor/pair.hpp | 3 + include/msgpack/adaptor/raw.hpp | 5 ++ include/msgpack/adaptor/set.hpp | 4 + include/msgpack/adaptor/string.hpp | 3 + include/msgpack/adaptor/tr1/unordered_map.hpp | 3 + include/msgpack/adaptor/tr1/unordered_set.hpp | 3 + include/msgpack/adaptor/vector.hpp | 3 + include/msgpack/adaptor/vector_char.hpp | 5 ++ include/msgpack/cpp_config.hpp | 13 +++- include/msgpack/detail/cpp03_zone.hpp | 5 ++ include/msgpack/detail/cpp11_zone.hpp | 6 ++ include/msgpack/fbuffer.hpp | 5 +- include/msgpack/object.hpp | 4 + include/msgpack/pack.hpp | 6 +- include/msgpack/sbuffer.hpp | 11 ++- include/msgpack/unpack.hpp | 6 ++ include/msgpack/versioning.hpp | 77 +++++++++++++++++++ include/msgpack/vrefbuffer.hpp | 5 ++ include/msgpack/zbuffer.hpp | 5 +- src/Makefile.am | 1 + 41 files changed, 261 insertions(+), 11 deletions(-) create mode 100644 include/msgpack/versioning.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 7c2dcceb..f984283b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -120,6 +120,7 @@ IF (MSGPACK_ENABLE_CXX) include/msgpack/type.hpp include/msgpack/unpack.hpp include/msgpack/version.hpp + include/msgpack/versioning.hpp include/msgpack/vrefbuffer.hpp include/msgpack/zbuffer.hpp include/msgpack/zone.hpp diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index 27d165e0..2e4a9db6 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -18,6 +18,8 @@ #ifndef MSGPACK_CPP03_DEFINE_HPP #define MSGPACK_CPP03_DEFINE_HPP +#include "msgpack/versioning.hpp" + #define MSGPACK_DEFINE(...) \ template \ void msgpack_pack(Packer& pk) const \ @@ -37,6 +39,7 @@ // MSGPACK_ADD_ENUM must be used in the global namespace. #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ template <> \ inline object const& operator>> (object const& o, enum& v) \ { \ @@ -58,9 +61,11 @@ } \ }; \ } \ + } \ } namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { namespace type { @@ -141,6 +146,7 @@ define, A<%=j%><%}%>> make_define(A0& a0<%1.upto(i) {|j|%>, <%}%> } // namespace type +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index 930f5368..c3e5006b 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -18,10 +18,13 @@ #ifndef MSGPACK_CPP03_MSGPACK_TUPLE_HPP #define MSGPACK_CPP03_MSGPACK_TUPLE_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + namespace type { // FIXME operator== @@ -191,6 +194,8 @@ inline void operator<< ( } <%}%> +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index da1656f5..25d69091 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -22,6 +22,7 @@ #include #include +#include "msgpack/versioning.hpp" #include "msgpack/cpp_config.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE @@ -35,6 +36,8 @@ <% GENERATION_LIMIT = 15 %> namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + class zone { struct finalizer { finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} @@ -301,6 +304,8 @@ T* zone::allocate(<%=(1..i).map{|j|"A#{j} a#{j}"}.join(', ')%>) } <%}%> +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif // MSGPACK_CPP03_ZONE_HPP diff --git a/include/msgpack/adaptor/bool.hpp b/include/msgpack/adaptor/bool.hpp index bdfb2408..e2b50a7a 100644 --- a/include/msgpack/adaptor/bool.hpp +++ b/include/msgpack/adaptor/bool.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_BOOL_HPP #define MSGPACK_TYPE_BOOL_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { inline object const& operator>> (object const& o, bool& v) { @@ -49,6 +51,8 @@ inline void operator<< (object::with_zone& o, bool v) { static_cast(o) << v; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif /* msgpack/type/bool.hpp */ diff --git a/include/msgpack/adaptor/char_ptr.hpp b/include/msgpack/adaptor/char_ptr.hpp index 2ef6c98b..5566040a 100644 --- a/include/msgpack/adaptor/char_ptr.hpp +++ b/include/msgpack/adaptor/char_ptr.hpp @@ -18,11 +18,14 @@ #ifndef MSGPACK_TYPE_CHAR_PTR_HPP #define MSGPACK_TYPE_CHAR_PTR_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + template inline packer& operator<< (packer& o, const char* v) { @@ -50,6 +53,7 @@ inline void operator<< (object& o, const char* v) o.via.str.size = static_cast(size); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp index 5c1cb3b0..5f7ac1b7 100644 --- a/include/msgpack/adaptor/cpp11/array.hpp +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -19,6 +19,8 @@ #ifndef MSGPACK_CPP11_ARRAY_HPP #define MSGPACK_CPP11_ARRAY_HPP +#include "msgpack/versioning.hpp" + #include #include "msgpack/object.hpp" @@ -26,6 +28,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + template inline object const& operator>> (object const& o, std::array& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -64,6 +68,7 @@ inline void operator<< (object::with_zone& o, const std::array& v) { } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp index a7cfcc2f..17a8605e 100644 --- a/include/msgpack/adaptor/cpp11/array_char.hpp +++ b/include/msgpack/adaptor/cpp11/array_char.hpp @@ -18,11 +18,14 @@ #ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP #define MSGPACK_TYPE_ARRAY_CHAR_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + template inline object const& operator>> (object const& o, std::array& v) { @@ -69,6 +72,8 @@ inline void operator<< (object::with_zone& o, const std::array& v) std::memcpy(ptr, v.data(), v.size()); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif // MSGPACK_TYPE_ARRAY_CHAR_HPP diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index 68e5ac22..f1a442e2 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -19,6 +19,8 @@ #ifndef MSGPACK_CPP11_FORWARD_LIST_HPP #define MSGPACK_CPP11_FORWARD_LIST_HPP +#include "msgpack/versioning.hpp" + #include #include "msgpack/object.hpp" @@ -26,6 +28,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + template inline object const& operator>> (object const& o, std::forward_list& v) { @@ -64,6 +68,7 @@ inline void operator<< (object::with_zone& o, const std::forward_list& v) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index 463c11a3..935c9fbf 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_CPP11_TUPLE_HPP #define MSGPACK_CPP11_TUPLE_HPP +#include "msgpack/versioning.hpp" + #include #include "msgpack/object.hpp" @@ -25,6 +27,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + // --- Pack ( from tuple to packer stream --- template struct StdTuplePacker { @@ -140,6 +144,8 @@ inline void operator<< ( StdTupleToObjectWithZone::convert(o, v); } -} // msgpack +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack #endif // MSGPACK_CPP11_TUPLE_HPP diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index f5609c88..11aad789 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_DEQUE_HPP #define MSGPACK_TYPE_DEQUE_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template inline object const& operator>> (object const& o, std::deque& v) @@ -70,6 +72,7 @@ inline void operator<< (object::with_zone& o, const std::deque& v) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index 8e2b4b2a..5463b3a7 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_CPP03_DEFINE_HPP #define MSGPACK_CPP03_DEFINE_HPP +#include "msgpack/versioning.hpp" + #define MSGPACK_DEFINE(...) \ template \ void msgpack_pack(Packer& pk) const \ @@ -37,6 +39,7 @@ // MSGPACK_ADD_ENUM must be used in the global namespace. #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ template <> \ inline object const& operator>> (object const& o, enum& v) \ { \ @@ -58,9 +61,11 @@ } \ }; \ } \ + } \ } namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { namespace type { @@ -3458,6 +3463,7 @@ define #define MSGPACK_DEFINE(...) \ @@ -39,6 +41,7 @@ // MSGPACK_ADD_ENUM must be used in the global namespace. #define MSGPACK_ADD_ENUM(enum) \ namespace msgpack { \ + MSGPACK_API_VERSION_NAMESPACE(v1) { \ template <> \ inline object const& operator>> (object const& o, enum& v) \ { \ @@ -61,9 +64,11 @@ } \ }; \ } \ + } \ } namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { namespace type { template @@ -165,6 +170,7 @@ define make_define(Args&... args) } } // namespace type +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack #endif // MSGPACK_CPP11_DEFINE_HPP diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 8b5aa607..84d4ae0b 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP #define MSGPACK_CPP11_MSGPACK_TUPLE_HPP +#include "msgpack/versioning.hpp" + #include #include "msgpack/object.hpp" @@ -25,6 +27,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + namespace type { // tuple using std::get; @@ -203,6 +207,8 @@ inline void operator<< ( MsgpackTupleToObjectWithZone::convert(o, v); } -} // msgpack +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack #endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp index b395850a..e1bc9306 100644 --- a/include/msgpack/adaptor/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -18,11 +18,14 @@ #ifndef MSGPACK_TYPE_FIXINT_HPP #define MSGPACK_TYPE_FIXINT_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include "msgpack/adaptor/int.hpp" namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + namespace type { @@ -202,6 +205,8 @@ inline void operator<< (object::with_zone& o, type::fix_uint64 v) { static_cast(o) << v; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif /* msgpack/type/fixint.hpp */ diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp index 16470e4b..3a5404b9 100644 --- a/include/msgpack/adaptor/float.hpp +++ b/include/msgpack/adaptor/float.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_FLOAT_HPP #define MSGPACK_TYPE_FLOAT_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { // FIXME check overflow, underflow @@ -96,6 +98,8 @@ inline void operator<< (object::with_zone& o, double v) { static_cast(o) << v; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif /* msgpack/type/float.hpp */ diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp index 305af663..92135cd4 100644 --- a/include/msgpack/adaptor/int.hpp +++ b/include/msgpack/adaptor/int.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_INT_HPP #define MSGPACK_TYPE_INT_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1){ namespace type { namespace detail { @@ -323,6 +325,8 @@ inline void operator<< (object::with_zone& o, const unsigned long long& v) { static_cast(o) << v; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif /* msgpack/type/int.hpp */ diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index 048eae00..5d0169d6 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_LIST_HPP #define MSGPACK_TYPE_LIST_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template inline object const& operator>> (object const& o, std::list& v) @@ -70,6 +72,7 @@ inline void operator<< (object::with_zone& o, const std::list& v) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index 5cf61762..be5add20 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -18,6 +18,7 @@ #ifndef MSGPACK_TYPE_MAP_HPP #define MSGPACK_TYPE_MAP_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include #include @@ -25,6 +26,7 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { namespace type { @@ -198,6 +200,7 @@ inline void operator<< (object::with_zone& o, const std::multimap& v) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp index f52d4ffe..af7f6308 100644 --- a/include/msgpack/adaptor/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -18,10 +18,13 @@ #ifndef MSGPACK_TYPE_NIL_HPP #define MSGPACK_TYPE_NIL_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + namespace type { struct nil { }; @@ -58,6 +61,7 @@ inline void object::as() const convert(v); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp index 851d00c3..10784af0 100644 --- a/include/msgpack/adaptor/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_PAIR_HPP #define MSGPACK_TYPE_PAIR_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template inline object const& operator>> (object const& o, std::pair& v) @@ -54,6 +56,7 @@ inline void operator<< (object::with_zone& o, const std::pair& v) p[1] = object(v.second, o.zone); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp index e2268607..c61e8cb5 100644 --- a/include/msgpack/adaptor/raw.hpp +++ b/include/msgpack/adaptor/raw.hpp @@ -18,12 +18,15 @@ #ifndef MSGPACK_TYPE_RAW_HPP #define MSGPACK_TYPE_RAW_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + namespace type { struct raw_ref { @@ -88,6 +91,8 @@ inline void operator<< (object::with_zone& o, const type::raw_ref& v) { static_cast(o) << v; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif /* msgpack/type/raw.hpp */ diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index f949944e..a714b4db 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -18,11 +18,14 @@ #ifndef MSGPACK_TYPE_SET_HPP #define MSGPACK_TYPE_SET_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" + #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template inline object const& operator>> (object const& o, std::set& v) @@ -115,6 +118,7 @@ inline void operator<< (object::with_zone& o, const std::multiset& v) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp index a1ea2f8c..f3fdd302 100644 --- a/include/msgpack/adaptor/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_STRING_HPP #define MSGPACK_TYPE_STRING_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { inline object const& operator>> (object const& o, std::string& v) { @@ -64,6 +66,7 @@ inline void operator<< (object& o, const std::string& v) o.via.str.size = static_cast(v.size()); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 6495fa9b..228cc584 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -18,6 +18,7 @@ #ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP #define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) @@ -42,6 +43,7 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map& v) @@ -141,6 +143,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index e6086c09..045bd0a9 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -18,6 +18,7 @@ #ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP #define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) @@ -41,6 +42,7 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template inline object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set& v) @@ -133,6 +135,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index 73856896..406b32f0 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -18,11 +18,13 @@ #ifndef MSGPACK_TYPE_VECTOR_HPP #define MSGPACK_TYPE_VECTOR_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template inline object const& operator>> (object const& o, std::vector& v) @@ -74,6 +76,7 @@ inline void operator<< (object::with_zone& o, const std::vector& v) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp index d87081d0..8675370b 100644 --- a/include/msgpack/adaptor/vector_char.hpp +++ b/include/msgpack/adaptor/vector_char.hpp @@ -18,11 +18,14 @@ #ifndef MSGPACK_TYPE_VECTOR_CHAR_HPP #define MSGPACK_TYPE_VECTOR_CHAR_HPP +#include "msgpack/versioning.hpp" #include "msgpack/object.hpp" #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + inline object const& operator>> (object const& o, std::vector& v) { switch (o.type) { @@ -66,6 +69,8 @@ inline void operator<< (object::with_zone& o, const std::vector& v) std::memcpy(ptr, v.data(), v.size()); } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif // MSGPACK_TYPE_VECTOR_CHAR_HPP diff --git a/include/msgpack/cpp_config.hpp b/include/msgpack/cpp_config.hpp index 72be9817..be00f6ef 100644 --- a/include/msgpack/cpp_config.hpp +++ b/include/msgpack/cpp_config.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_CPP_CONFIG_HPP #define MSGPACK_CPP_CONFIG_HPP +#include "msgpack/versioning.hpp" + #if !defined(MSGPACK_USE_CPP03) // If MSVC would support C++11 completely, // then 'defined(_MSC_VER)' would replace with @@ -40,6 +42,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + template struct unique_ptr : std::auto_ptr { explicit unique_ptr(T* p = 0) throw() : std::auto_ptr(p) {} @@ -69,7 +73,9 @@ template struct enable_if { }; -} // msgpack +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack #else // __cplusplus < 201103 @@ -78,6 +84,8 @@ struct enable_if { #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + // unique_ptr using std::unique_ptr; // using std::make_unique; // since C++14 @@ -88,7 +96,8 @@ namespace msgpack { using std::swap; using std::enable_if; -} // msgpack +} // MSGPACK_API_VERSION_NAMESPACE(v1) +} // namespace msgpack #endif // __cplusplus < 201103 diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index 989398da..cc09b6a8 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -22,6 +22,7 @@ #include #include +#include "msgpack/versioning.hpp" #include "msgpack/cpp_config.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE @@ -35,6 +36,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + class zone { struct finalizer { finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} @@ -631,6 +634,8 @@ T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif // MSGPACK_CPP03_ZONE_HPP diff --git a/include/msgpack/detail/cpp11_zone.hpp b/include/msgpack/detail/cpp11_zone.hpp index f768f008..f3ec210b 100644 --- a/include/msgpack/detail/cpp11_zone.hpp +++ b/include/msgpack/detail/cpp11_zone.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_CPP11_ZONE_HPP #define MSGPACK_CPP11_ZONE_HPP +#include "msgpack/versioning.hpp" + #include #include #include @@ -34,6 +36,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + class zone { private: struct finalizer { @@ -341,6 +345,8 @@ T* zone::allocate(Args... args) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif // MSGPACK_CPP11_ZONE_HPP diff --git a/include/msgpack/fbuffer.hpp b/include/msgpack/fbuffer.hpp index 5d974d6f..39bb4089 100644 --- a/include/msgpack/fbuffer.hpp +++ b/include/msgpack/fbuffer.hpp @@ -18,11 +18,14 @@ #ifndef MSGPACK_FBUFFER_HPP__ #define MSGPACK_FBUFFER_HPP__ +#include "msgpack/versioning.hpp" + #include #include namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { class fbuffer { public: @@ -49,8 +52,8 @@ private: FILE* m_file; }; +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack #endif /* msgpack/fbuffer.hpp */ - diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index f060450b..f96543e2 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -18,6 +18,7 @@ #ifndef MSGPACK_OBJECT_HPP #define MSGPACK_OBJECT_HPP +#include "msgpack/versioning.hpp" #include "object.h" #include "pack.hpp" #include "zone.hpp" @@ -29,6 +30,7 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { class type_error : public std::bad_cast { }; @@ -568,6 +570,8 @@ inline std::ostream& operator<< (std::ostream& s, const object& o) return s; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #include "msgpack/type.hpp" diff --git a/include/msgpack/pack.hpp b/include/msgpack/pack.hpp index bfae2dd2..088d69a6 100644 --- a/include/msgpack/pack.hpp +++ b/include/msgpack/pack.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_PACK_HPP #define MSGPACK_PACK_HPP +#include "msgpack/versioning.hpp" + #include #include #include @@ -26,6 +28,7 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { template class packer { @@ -1018,7 +1021,8 @@ inline void packer::pack_imp_int64(T d) } } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack #endif /* msgpack/pack.hpp */ - diff --git a/include/msgpack/sbuffer.hpp b/include/msgpack/sbuffer.hpp index 76f4be25..531f9f16 100644 --- a/include/msgpack/sbuffer.hpp +++ b/include/msgpack/sbuffer.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_SBUFFER_HPP #define MSGPACK_SBUFFER_HPP +#include "msgpack/versioning.hpp" + #include #ifndef MSGPACK_SBUFFER_INIT_SIZE @@ -26,6 +28,7 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { class sbuffer { public: @@ -90,14 +93,14 @@ private: { size_t nsize = (m_alloc > 0) ? m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - + while(nsize < m_size + len) { nsize *= 2; } - + void* tmp = ::realloc(m_data, nsize); if(!tmp) { throw std::bad_alloc(); } - + m_data = static_cast(tmp); m_alloc = nsize; } @@ -110,8 +113,8 @@ private: size_t m_alloc; }; +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack #endif /* msgpack/sbuffer.hpp */ - diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index e7be9f20..ef0bfa91 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -17,6 +17,8 @@ // #ifndef MSGPACK_UNPACK_HPP #define MSGPACK_UNPACK_HPP + +#include "msgpack/versioning.hpp" #include "object.hpp" #include "zone.hpp" #include "unpack_define.h" @@ -47,6 +49,8 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + typedef bool (*unpack_reference_func)(type::object_type, uint64_t, void*); namespace detail { @@ -1456,6 +1460,8 @@ inline bool unpacker::default_reference_func(type::object_type /*type*/, uint64_ return true; } +} // MSGPACK_API_VERSION_NAMESPACE(v1) + } // namespace msgpack diff --git a/include/msgpack/versioning.hpp b/include/msgpack/versioning.hpp new file mode 100644 index 00000000..cb589ea3 --- /dev/null +++ b/include/msgpack/versioning.hpp @@ -0,0 +1,77 @@ +/* + * MessagePack for C++ version switcher + * + * Copyright (C) 2014 KONDO Takatoshi + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_VERSIONING_HPP +#define MSGPACK_VERSIONING_HPP + +#if !defined(MSGPACK_DEFAULT_API_VERSION) +#define MSGPACK_DEFAULT_API_VERSION 1 +#endif + +#define MSGPACK_DEFAULT_API_NS MSGPACK_PP_CAT(v, MSGPACK_DEFAULT_API_VERSION) + +#if MSGPACK_DEFAULT_API_VERSION == 1 +#define MSGPACK_PP_ENABLE_NS_v1 () +//#elif MSGPACK_DEFAULT_API_VERSION == 2 +//#define MSGPACK_PP_ENABLE_NS_v2 () +#else +#error +#endif + +#define MSGPACK_PP_CAT(a, ...) MSGPACK_PP_PRIMITIVE_CAT(a, __VA_ARGS__) +#define MSGPACK_PP_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__ + +#define MSGPACK_PP_IIF(c) MSGPACK_PP_PRIMITIVE_CAT(MSGPACK_PP_IIF_, c) +#define MSGPACK_PP_IIF_0(t, ...) __VA_ARGS__ +#define MSGPACK_PP_IIF_1(t, ...) t + +#define MSGPACK_PP_PROBE(x) x, 1 + +#if defined(__MSC_VER) + +#define MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(define, args) define args +#define MSGPACK_PP_CHECK(...) MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(MSGPACK_PP_CHECK_N, (__VA_ARGS__, 0)) +#define MSGPACK_PP_CHECK_N(x, n, ...) n + +#else // defined(__MSC_VER) + +#define MSGPACK_PP_CHECK(...) MSGPACK_PP_CHECK_N(__VA_ARGS__, 0) +#define MSGPACK_PP_CHECK_N(x, n, ...) n + +#endif // defined(__MSC_VER) + + +#define MSGPACK_PP_NS_ENABLED_PROBE(ns) MSGPACK_PP_NS_ENABLED_PROBE_PROXY( MSGPACK_PP_ENABLE_NS_##ns ) +#define MSGPACK_PP_NS_ENABLED_PROBE_PROXY(...) MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(__VA_ARGS__) +#define MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(x) MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_ x +#define MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_(...) MSGPACK_PP_PROBE(~) + +#define MSGPACK_PP_IS_NS_ENABLED(ns) MSGPACK_PP_CHECK(MSGPACK_PP_NS_ENABLED_PROBE(ns)) + +#if __cplusplus < 201103 +#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \ + (namespace ns{}; using namespace ns; namespace ns, \ + namespace ns) + +#else // __cplusplus < 201103 + +#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \ + (inline namespace ns, namespace ns) + +#endif // __cplusplus < 201103 + +#endif // MSGPACK_VERSIONING_HPP diff --git a/include/msgpack/vrefbuffer.hpp b/include/msgpack/vrefbuffer.hpp index 4ce6cb45..28cd31ca 100644 --- a/include/msgpack/vrefbuffer.hpp +++ b/include/msgpack/vrefbuffer.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_VREFBUFFER_HPP #define MSGPACK_VREFBUFFER_HPP +#include "msgpack/versioning.hpp" + #include #ifndef MSGPACK_VREFBUFFER_REF_SIZE @@ -39,6 +41,8 @@ struct iovec { namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { + namespace detail { // int64, uint64, double std::size_t const packer_max_buffer_size = 9; @@ -274,6 +278,7 @@ private: }; +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack diff --git a/include/msgpack/zbuffer.hpp b/include/msgpack/zbuffer.hpp index 6dd72341..43a9d77b 100644 --- a/include/msgpack/zbuffer.hpp +++ b/include/msgpack/zbuffer.hpp @@ -18,6 +18,8 @@ #ifndef MSGPACK_ZBUFFER_HPP #define MSGPACK_ZBUFFER_HPP +#include "msgpack/versioning.hpp" + #include #include @@ -31,6 +33,7 @@ namespace msgpack { +MSGPACK_API_VERSION_NAMESPACE(v1) { class zbuffer { public: @@ -155,8 +158,8 @@ private: size_t m_init_size; }; +} // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack #endif /* msgpack/zbuffer.hpp */ - diff --git a/src/Makefile.am b/src/Makefile.am index 039aeacd..b3245236 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -89,6 +89,7 @@ nobase_include_HEADERS += \ ../include/msgpack/type.hpp \ ../include/msgpack/unpack.hpp \ ../include/msgpack/version.hpp \ + ../include/msgpack/versioning.hpp \ ../include/msgpack/vrefbuffer.hpp \ ../include/msgpack/zbuffer.hpp \ ../include/msgpack/zone.hpp From 4c00f448aa2eb1ea781e3b885e33e5a16a570542 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Mon, 13 Oct 2014 00:04:10 +0900 Subject: [PATCH 144/153] Added a minimal forward declaration header file for pack/unpack overloading. --- CMakeLists.txt | 2 + erb/cpp03_define.hpp.erb | 1 + erb/cpp03_msgpack_tuple.hpp.erb | 2 +- erb/cpp03_zone.hpp.erb | 2 +- include/msgpack/adaptor/bool.hpp | 2 +- include/msgpack/adaptor/char_ptr.hpp | 2 +- include/msgpack/adaptor/cpp11/array.hpp | 4 +- include/msgpack/adaptor/cpp11/array_char.hpp | 2 +- .../msgpack/adaptor/cpp11/forward_list.hpp | 4 +- include/msgpack/adaptor/cpp11/tuple.hpp | 4 +- include/msgpack/adaptor/deque.hpp | 2 +- .../msgpack/adaptor/detail/cpp03_define.hpp | 1 + .../adaptor/detail/cpp03_msgpack_tuple.hpp | 2 +- .../msgpack/adaptor/detail/cpp11_define.hpp | 1 + .../adaptor/detail/cpp11_msgpack_tuple.hpp | 4 +- include/msgpack/adaptor/fixint.hpp | 2 +- include/msgpack/adaptor/float.hpp | 2 +- include/msgpack/adaptor/int.hpp | 2 +- include/msgpack/adaptor/list.hpp | 2 +- include/msgpack/adaptor/map.hpp | 2 +- include/msgpack/adaptor/nil.hpp | 2 +- include/msgpack/adaptor/pair.hpp | 2 +- include/msgpack/adaptor/raw.hpp | 2 +- include/msgpack/adaptor/set.hpp | 2 +- include/msgpack/adaptor/string.hpp | 2 +- include/msgpack/adaptor/tr1/unordered_map.hpp | 2 +- include/msgpack/adaptor/tr1/unordered_set.hpp | 2 +- include/msgpack/adaptor/vector.hpp | 2 +- include/msgpack/adaptor/vector_char.hpp | 2 +- include/msgpack/detail/cpp03_zone.hpp | 2 +- include/msgpack/object.hpp | 116 +------------- include/msgpack/object_forward.hpp | 144 ++++++++++++++++++ include/msgpack_forward.hpp | 26 ++++ src/Makefile.am | 2 + 34 files changed, 207 insertions(+), 146 deletions(-) create mode 100644 include/msgpack/object_forward.hpp create mode 100644 include/msgpack_forward.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index f984283b..af1aefe8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -84,6 +84,7 @@ LIST (APPEND msgpack_HEADERS IF (MSGPACK_ENABLE_CXX) LIST (APPEND msgpack_HEADERS include/msgpack.hpp + include/msgpack_forward.hpp include/msgpack/adaptor/bool.hpp include/msgpack/adaptor/char_ptr.hpp include/msgpack/adaptor/cpp11/array.hpp @@ -115,6 +116,7 @@ IF (MSGPACK_ENABLE_CXX) include/msgpack/detail/cpp11_zone.hpp include/msgpack/fbuffer.hpp include/msgpack/object.hpp + include/msgpack/object_forward.hpp include/msgpack/pack.hpp include/msgpack/sbuffer.hpp include/msgpack/type.hpp diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index 2e4a9db6..e4350202 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -19,6 +19,7 @@ #define MSGPACK_CPP03_DEFINE_HPP #include "msgpack/versioning.hpp" +#include "msgpack_forward.hpp" #define MSGPACK_DEFINE(...) \ template \ diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index c3e5006b..582762d2 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" namespace msgpack { diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index 25d69091..69261065 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -23,7 +23,7 @@ #include #include "msgpack/versioning.hpp" -#include "msgpack/cpp_config.hpp" +#include "msgpack_forward.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 diff --git a/include/msgpack/adaptor/bool.hpp b/include/msgpack/adaptor/bool.hpp index e2b50a7a..1d794dd1 100644 --- a/include/msgpack/adaptor/bool.hpp +++ b/include/msgpack/adaptor/bool.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_BOOL_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/char_ptr.hpp b/include/msgpack/adaptor/char_ptr.hpp index 5566040a..cf013b34 100644 --- a/include/msgpack/adaptor/char_ptr.hpp +++ b/include/msgpack/adaptor/char_ptr.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_CHAR_PTR_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp index 5f7ac1b7..e9e1c972 100644 --- a/include/msgpack/adaptor/cpp11/array.hpp +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -20,12 +20,10 @@ #define MSGPACK_CPP11_ARRAY_HPP #include "msgpack/versioning.hpp" +#include "msgpack_forward.hpp" #include -#include "msgpack/object.hpp" -#include "msgpack/cpp_config.hpp" - namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(v1) { diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp index 17a8605e..34aa2761 100644 --- a/include/msgpack/adaptor/cpp11/array_char.hpp +++ b/include/msgpack/adaptor/cpp11/array_char.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_ARRAY_CHAR_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index f1a442e2..d2dbebb9 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -20,12 +20,10 @@ #define MSGPACK_CPP11_FORWARD_LIST_HPP #include "msgpack/versioning.hpp" +#include "msgpack_forward.hpp" #include -#include "msgpack/object.hpp" -#include "msgpack/cpp_config.hpp" - namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(v1) { diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index 935c9fbf..704d81ab 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -19,12 +19,10 @@ #define MSGPACK_CPP11_TUPLE_HPP #include "msgpack/versioning.hpp" +#include "msgpack_forward.hpp" #include -#include "msgpack/object.hpp" -#include "msgpack/cpp_config.hpp" - namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(v1) { diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index 11aad789..364baff3 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_DEQUE_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index 5463b3a7..d9090236 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -19,6 +19,7 @@ #define MSGPACK_CPP03_DEFINE_HPP #include "msgpack/versioning.hpp" +#include "msgpack_forward.hpp" #define MSGPACK_DEFINE(...) \ template \ diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp index ac8c7807..3ffd0e29 100644 --- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" namespace msgpack { diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index 8ec9b469..b8a0979f 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -19,6 +19,7 @@ #define MSGPACK_CPP11_DEFINE_HPP #include "msgpack/versioning.hpp" +#include "msgpack_forward.hpp" #include diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 84d4ae0b..4f190a86 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -19,12 +19,10 @@ #define MSGPACK_CPP11_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" +#include "msgpack_forward.hpp" #include -#include "msgpack/object.hpp" -#include "msgpack/cpp_config.hpp" - namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(v1) { diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp index e1bc9306..ca5e6b02 100644 --- a/include/msgpack/adaptor/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_FIXINT_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include "msgpack/adaptor/int.hpp" namespace msgpack { diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp index 3a5404b9..bbace593 100644 --- a/include/msgpack/adaptor/float.hpp +++ b/include/msgpack/adaptor/float.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_FLOAT_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp index 92135cd4..6491d274 100644 --- a/include/msgpack/adaptor/int.hpp +++ b/include/msgpack/adaptor/int.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_INT_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index 5d0169d6..b7690dd7 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_LIST_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index be5add20..de9f825e 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_MAP_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include #include #include diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp index af7f6308..c8f2a0c7 100644 --- a/include/msgpack/adaptor/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_NIL_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" namespace msgpack { diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp index 10784af0..238abb8e 100644 --- a/include/msgpack/adaptor/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_PAIR_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp index c61e8cb5..52790519 100644 --- a/include/msgpack/adaptor/raw.hpp +++ b/include/msgpack/adaptor/raw.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_RAW_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include #include diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index a714b4db..a01b1618 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_SET_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp index f3fdd302..66068361 100644 --- a/include/msgpack/adaptor/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_STRING_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 228cc584..77399581 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index 045bd0a9..e81fe590 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index 406b32f0..21f2f085 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_VECTOR_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp index 8675370b..a702f445 100644 --- a/include/msgpack/adaptor/vector_char.hpp +++ b/include/msgpack/adaptor/vector_char.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_VECTOR_CHAR_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" +#include "msgpack_forward.hpp" #include namespace msgpack { diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index cc09b6a8..b2acd3d8 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -23,7 +23,7 @@ #include #include "msgpack/versioning.hpp" -#include "msgpack/cpp_config.hpp" +#include "msgpack_forward.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index f96543e2..7e22426c 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -1,7 +1,7 @@ // // MessagePack for C++ static resolution routine // -// Copyright (C) 2008-2010 FURUHASHI Sadayuki +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -19,9 +19,9 @@ #define MSGPACK_OBJECT_HPP #include "msgpack/versioning.hpp" -#include "object.h" -#include "pack.hpp" -#include "zone.hpp" +#include "msgpack/object_forward.hpp" +#include "msgpack/pack.hpp" +#include "msgpack/zone.hpp" #include #include #include @@ -32,114 +32,6 @@ namespace msgpack { MSGPACK_API_VERSION_NAMESPACE(v1) { -class type_error : public std::bad_cast { }; - - -namespace type { - enum object_type { - NIL = MSGPACK_OBJECT_NIL, - BOOLEAN = MSGPACK_OBJECT_BOOLEAN, - POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, - NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, - DOUBLE = MSGPACK_OBJECT_DOUBLE, - STR = MSGPACK_OBJECT_STR, - BIN = MSGPACK_OBJECT_BIN, - ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP, - EXT = MSGPACK_OBJECT_EXT - }; -} - - -struct object; -struct object_kv; - -struct object_array { - uint32_t size; - object* ptr; -}; - -struct object_map { - uint32_t size; - object_kv* ptr; -}; - -struct object_str { - uint32_t size; - const char* ptr; -}; - -struct object_bin { - uint32_t size; - const char* ptr; -}; - -struct object_ext { - int8_t type() const { return ptr[0]; } - const char* data() const { return &ptr[1]; } - uint32_t size; - const char* ptr; -}; - -struct object { - union union_type { - bool boolean; - uint64_t u64; - int64_t i64; - double dec; - object_array array; - object_map map; - object_str str; - object_bin bin; - object_ext ext; - }; - - type::object_type type; - union_type via; - - bool is_nil() const { return type == type::NIL; } - - template - T as() const; - - template - void convert(T& v) const; - template - void convert(T* v) const; - - object(); - - object(msgpack_object o); - - template - explicit object(const T& v); - - template - object(const T& v, zone& z); - - // obsolete - template - object(const T& v, zone* z); - - template - object& operator=(const T& v); - - operator msgpack_object() const; - - struct with_zone; - -private: - struct implicit_type; - -public: - implicit_type convert() const; -}; - -struct object_kv { - object key; - object val; -}; - struct object::with_zone : object { with_zone(msgpack::zone& zone) : zone(zone) { } msgpack::zone& zone; diff --git a/include/msgpack/object_forward.hpp b/include/msgpack/object_forward.hpp new file mode 100644 index 00000000..cad24f45 --- /dev/null +++ b/include/msgpack/object_forward.hpp @@ -0,0 +1,144 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_OBJECT_FORWARD_HPP +#define MSGPACK_OBJECT_FORWARD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/zone.hpp" +#include "msgpack/object.h" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + + +namespace type { + enum object_type { + NIL = MSGPACK_OBJECT_NIL, + BOOLEAN = MSGPACK_OBJECT_BOOLEAN, + POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, + NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, + DOUBLE = MSGPACK_OBJECT_DOUBLE, + STR = MSGPACK_OBJECT_STR, + BIN = MSGPACK_OBJECT_BIN, + ARRAY = MSGPACK_OBJECT_ARRAY, + MAP = MSGPACK_OBJECT_MAP, + EXT = MSGPACK_OBJECT_EXT + }; +} + + +struct object; +struct object_kv; + +struct object_array { + uint32_t size; + object* ptr; +}; + +struct object_map { + uint32_t size; + object_kv* ptr; +}; + +struct object_str { + uint32_t size; + const char* ptr; +}; + +struct object_bin { + uint32_t size; + const char* ptr; +}; + +struct object_ext { + int8_t type() const { return ptr[0]; } + const char* data() const { return &ptr[1]; } + uint32_t size; + const char* ptr; +}; + +struct object { + union union_type { + bool boolean; + uint64_t u64; + int64_t i64; + double dec; + object_array array; + object_map map; + object_str str; + object_bin bin; + object_ext ext; + }; + + type::object_type type; + union_type via; + + bool is_nil() const { return type == type::NIL; } + + template + T as() const; + + template + void convert(T& v) const; + template + void convert(T* v) const; + + object(); + + object(msgpack_object o); + + template + explicit object(const T& v); + + template + object(const T& v, zone& z); + + // obsolete + template + object(const T& v, zone* z); + + template + object& operator=(const T& v); + + operator msgpack_object() const; + + struct with_zone; + +private: + struct implicit_type; + +public: + implicit_type convert() const; +}; + +class type_error : public std::bad_cast { }; + +struct object_kv { + object key; + object val; +}; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_OBJECT_FORWARD_HPP diff --git a/include/msgpack_forward.hpp b/include/msgpack_forward.hpp new file mode 100644 index 00000000..90963fe6 --- /dev/null +++ b/include/msgpack_forward.hpp @@ -0,0 +1,26 @@ +/* + * MessagePack for C++ version switcher + * + * Copyright (C) 2014 KONDO Takatoshi + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef MSGPACK_FORWARD_HPP +#define MSGPACK_FORWARD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/zone.hpp" +#include "msgpack/object_forward.hpp" +#include "msgpack/pack.hpp" + +#endif // MSGPACK_FORWARD_HPP diff --git a/src/Makefile.am b/src/Makefile.am index b3245236..df0a872c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -53,6 +53,7 @@ nobase_include_HEADERS = \ if ENABLE_CXX nobase_include_HEADERS += \ ../include/msgpack.hpp \ + ../include/msgpack_forward.hpp \ ../include/msgpack/adaptor/bool.hpp \ ../include/msgpack/adaptor/char_ptr.hpp \ ../include/msgpack/adaptor/cpp11/array.hpp \ @@ -84,6 +85,7 @@ nobase_include_HEADERS += \ ../include/msgpack/detail/cpp11_zone.hpp \ ../include/msgpack/fbuffer.hpp \ ../include/msgpack/object.hpp \ + ../include/msgpack/object_forward.hpp \ ../include/msgpack/pack.hpp \ ../include/msgpack/sbuffer.hpp \ ../include/msgpack/type.hpp \ From 479d50bd93bf65f4328c48832e76a2514193d37b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sat, 11 Oct 2014 23:45:21 +0900 Subject: [PATCH 145/153] Replaced uint64_t with apropriate types. --- include/msgpack/unpack.hpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index e7be9f20..54d5c110 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -47,7 +47,7 @@ namespace msgpack { -typedef bool (*unpack_reference_func)(type::object_type, uint64_t, void*); +typedef bool (*unpack_reference_func)(type::object_type, std::size_t, void*); namespace detail { @@ -149,7 +149,7 @@ inline void unpack_map_item(object& c, object const& k, object const& v) ++c.via.map.size; } -inline void unpack_str(unpack_user& u, const char* p, uint64_t l, object& o) +inline void unpack_str(unpack_user& u, const char* p, uint32_t l, object& o) { o.type = type::STR; if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { @@ -164,7 +164,7 @@ inline void unpack_str(unpack_user& u, const char* p, uint64_t l, object& o) o.via.str.size = l; } -inline void unpack_bin(unpack_user& u, const char* p, uint64_t l, object& o) +inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, object& o) { o.type = type::BIN; if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { @@ -179,7 +179,7 @@ inline void unpack_bin(unpack_user& u, const char* p, uint64_t l, object& o) o.via.bin.size = l; } -inline void unpack_ext(unpack_user& u, const char* p, uint64_t l, object& o) +inline void unpack_ext(unpack_user& u, const char* p, uint32_t l, object& o) { o.type = type::EXT; if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { @@ -796,7 +796,7 @@ private: char const* m_start; char const* m_current; - uint64_t m_trail; + uint32_t m_trail; unpack_user m_user; uint32_t m_cs; uint32_t m_top; @@ -947,7 +947,7 @@ private: void expand_buffer(std::size_t size); int execute_imp(); bool flush_zone(); - static bool default_reference_func(type::object_type type, uint64_t len, void*); + static bool default_reference_func(type::object_type type, std::size_t len, void*); private: char* m_buffer; @@ -1451,7 +1451,7 @@ inline void unpack(unpacked* result, else unpack(*result, data, len, f, user_data); } -inline bool unpacker::default_reference_func(type::object_type /*type*/, uint64_t /*len*/, void*) +inline bool unpacker::default_reference_func(type::object_type /*type*/, std::size_t /*len*/, void*) { return true; } From 1e7fbc03491efd0fe3d42a68369fb3dbdc475026 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 12 Oct 2014 00:20:54 +0900 Subject: [PATCH 146/153] Removed wrong tr1:: from unordered containers. --- test/object_with_zone.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/object_with_zone.cpp b/test/object_with_zone.cpp index 34349941..b020e3b3 100644 --- a/test/object_with_zone.cpp +++ b/test/object_with_zone.cpp @@ -533,7 +533,7 @@ TEST(object_with_zone, unordered_multimap) msgpack::object obj(v1, z); test_t v2 = obj.as(); vector > vec1, vec2; - tr1::unordered_multimap::const_iterator it; + unordered_multimap::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) vec1.push_back(make_pair(it->first, it->second)); for (it = v2.begin(); it != v2.end(); ++it) @@ -561,7 +561,7 @@ TEST(object_with_zone, unordered_set) msgpack::object obj(v1, z); test_t v2 = obj.as(); EXPECT_EQ(v1.size(), v2.size()); - tr1::unordered_set::const_iterator it; + unordered_set::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) EXPECT_TRUE(v2.find(*it) != v2.end()); } @@ -581,7 +581,7 @@ TEST(object_with_zone, unordered_multiset) msgpack::object obj(v1, z); test_t v2 = obj.as(); vector vec1, vec2; - tr1::unordered_multiset::const_iterator it; + unordered_multiset::const_iterator it; for (it = v1.begin(); it != v1.end(); ++it) vec1.push_back(*it); for (it = v2.begin(); it != v2.end(); ++it) From 4a292193f2b7a0ee204b108d55476816278d2024 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 12 Oct 2014 01:22:10 +0900 Subject: [PATCH 147/153] Moved include byteswap.h to sysdep.h. When compiling on Mac, byteswap.h is not included. --- include/msgpack/sysdep.h | 6 +++++- include/msgpack/unpack.hpp | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/include/msgpack/sysdep.h b/include/msgpack/sysdep.h index 0613c423..5b8a739e 100644 --- a/include/msgpack/sysdep.h +++ b/include/msgpack/sysdep.h @@ -68,7 +68,12 @@ typedef unsigned int _msgpack_atomic_counter_t; #endif #else + #include /* __BYTE_ORDER */ +# if !defined(__APPLE__) +# include +# endif + #endif #if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) @@ -185,4 +190,3 @@ typedef unsigned int _msgpack_atomic_counter_t; #endif #endif /* msgpack/sysdep.h */ - diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp index e7be9f20..11926c91 100644 --- a/include/msgpack/unpack.hpp +++ b/include/msgpack/unpack.hpp @@ -21,10 +21,10 @@ #include "zone.hpp" #include "unpack_define.h" #include "cpp_config.hpp" +#include "sysdep.h" #include #include -#include From db8578a62b9fea3f41dc0e0426d16c29628b23d3 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Wed, 15 Oct 2014 17:32:15 +0900 Subject: [PATCH 148/153] Separated adaptor functions' definitions and declarations. --- CMakeLists.txt | 29 +- erb/cpp03_define.hpp.erb | 2 +- erb/cpp03_msgpack_tuple.hpp.erb | 12 +- erb/cpp03_msgpack_tuple_fwd.hpp.erb | 125 + erb/cpp03_zone.hpp.erb | 2 +- include/msgpack/adaptor/bool.hpp | 4 +- include/msgpack/adaptor/bool_fwd.hpp | 39 + include/msgpack/adaptor/char_ptr.hpp | 2 +- include/msgpack/adaptor/char_ptr_fwd.hpp | 38 + include/msgpack/adaptor/cpp11/array.hpp | 2 +- include/msgpack/adaptor/cpp11/array_char.hpp | 2 +- .../msgpack/adaptor/cpp11/array_char_fwd.hpp | 45 + include/msgpack/adaptor/cpp11/array_fwd.hpp | 44 + .../msgpack/adaptor/cpp11/forward_list.hpp | 2 +- .../adaptor/cpp11/forward_list_fwd.hpp | 44 + include/msgpack/adaptor/cpp11/tuple.hpp | 6 +- include/msgpack/adaptor/cpp11/tuple_fwd.hpp | 62 + include/msgpack/adaptor/deque.hpp | 2 +- include/msgpack/adaptor/deque_fwd.hpp | 40 + .../msgpack/adaptor/detail/cpp03_define.hpp | 2 +- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 198 +- .../detail/cpp03_msgpack_tuple_fwd.hpp | 4341 +++++++++++++++++ .../msgpack/adaptor/detail/cpp11_define.hpp | 2 +- .../adaptor/detail/cpp11_msgpack_tuple.hpp | 2 +- .../detail/cpp11_msgpack_tuple_fwd.hpp | 84 + include/msgpack/adaptor/fixint.hpp | 2 +- include/msgpack/adaptor/fixint_fwd.hpp | 100 + include/msgpack/adaptor/float.hpp | 4 +- include/msgpack/adaptor/float_fwd.hpp | 44 + include/msgpack/adaptor/int.hpp | 2 +- include/msgpack/adaptor/int_fwd.hpp | 100 + include/msgpack/adaptor/list.hpp | 4 +- include/msgpack/adaptor/list_fwd.hpp | 40 + include/msgpack/adaptor/map.hpp | 4 +- include/msgpack/adaptor/map_fwd.hpp | 69 + include/msgpack/adaptor/msgpack_tuple_fwd.hpp | 29 + include/msgpack/adaptor/nil.hpp | 4 +- include/msgpack/adaptor/nil_fwd.hpp | 51 + include/msgpack/adaptor/pair.hpp | 4 +- include/msgpack/adaptor/pair_fwd.hpp | 42 + include/msgpack/adaptor/raw.hpp | 4 +- include/msgpack/adaptor/raw_fwd.hpp | 50 + include/msgpack/adaptor/set.hpp | 4 +- include/msgpack/adaptor/set_fwd.hpp | 52 + include/msgpack/adaptor/string.hpp | 4 +- include/msgpack/adaptor/string_fwd.hpp | 42 + include/msgpack/adaptor/tr1/unordered_map.hpp | 4 +- .../msgpack/adaptor/tr1/unordered_map_fwd.hpp | 72 + include/msgpack/adaptor/tr1/unordered_set.hpp | 4 +- .../msgpack/adaptor/tr1/unordered_set_fwd.hpp | 71 + include/msgpack/adaptor/vector.hpp | 4 +- include/msgpack/adaptor/vector_char.hpp | 2 +- include/msgpack/adaptor/vector_char_fwd.hpp | 42 + include/msgpack/adaptor/vector_fwd.hpp | 42 + include/msgpack/detail/cpp03_zone.hpp | 2 +- include/msgpack/object.hpp | 91 +- .../{object_forward.hpp => object_fwd.hpp} | 27 +- .../{msgpack_forward.hpp => msgpack_fwd.hpp} | 8 +- preprocess | 1 + src/Makefile.am | 29 +- 60 files changed, 5994 insertions(+), 191 deletions(-) create mode 100644 erb/cpp03_msgpack_tuple_fwd.hpp.erb create mode 100644 include/msgpack/adaptor/bool_fwd.hpp create mode 100644 include/msgpack/adaptor/char_ptr_fwd.hpp create mode 100644 include/msgpack/adaptor/cpp11/array_char_fwd.hpp create mode 100644 include/msgpack/adaptor/cpp11/array_fwd.hpp create mode 100644 include/msgpack/adaptor/cpp11/forward_list_fwd.hpp create mode 100644 include/msgpack/adaptor/cpp11/tuple_fwd.hpp create mode 100644 include/msgpack/adaptor/deque_fwd.hpp create mode 100644 include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp create mode 100644 include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp create mode 100644 include/msgpack/adaptor/fixint_fwd.hpp create mode 100644 include/msgpack/adaptor/float_fwd.hpp create mode 100644 include/msgpack/adaptor/int_fwd.hpp create mode 100644 include/msgpack/adaptor/list_fwd.hpp create mode 100644 include/msgpack/adaptor/map_fwd.hpp create mode 100644 include/msgpack/adaptor/msgpack_tuple_fwd.hpp create mode 100644 include/msgpack/adaptor/nil_fwd.hpp create mode 100644 include/msgpack/adaptor/pair_fwd.hpp create mode 100644 include/msgpack/adaptor/raw_fwd.hpp create mode 100644 include/msgpack/adaptor/set_fwd.hpp create mode 100644 include/msgpack/adaptor/string_fwd.hpp create mode 100644 include/msgpack/adaptor/tr1/unordered_map_fwd.hpp create mode 100644 include/msgpack/adaptor/tr1/unordered_set_fwd.hpp create mode 100644 include/msgpack/adaptor/vector_char_fwd.hpp create mode 100644 include/msgpack/adaptor/vector_fwd.hpp rename include/msgpack/{object_forward.hpp => object_fwd.hpp} (83%) rename include/{msgpack_forward.hpp => msgpack_fwd.hpp} (86%) diff --git a/CMakeLists.txt b/CMakeLists.txt index af1aefe8..d5311f4c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -84,39 +84,64 @@ LIST (APPEND msgpack_HEADERS IF (MSGPACK_ENABLE_CXX) LIST (APPEND msgpack_HEADERS include/msgpack.hpp - include/msgpack_forward.hpp + include/msgpack_fwd.hpp include/msgpack/adaptor/bool.hpp + include/msgpack/adaptor/bool_fwd.hpp include/msgpack/adaptor/char_ptr.hpp + include/msgpack/adaptor/char_ptr_fwd.hpp include/msgpack/adaptor/cpp11/array.hpp + include/msgpack/adaptor/cpp11/array_fwd.hpp include/msgpack/adaptor/cpp11/array_char.hpp + include/msgpack/adaptor/cpp11/array_char_fwd.hpp include/msgpack/adaptor/cpp11/forward_list.hpp + include/msgpack/adaptor/cpp11/forward_list_fwd.hpp include/msgpack/adaptor/cpp11/tuple.hpp + include/msgpack/adaptor/cpp11/tuple_fwd.hpp include/msgpack/adaptor/define.hpp include/msgpack/adaptor/deque.hpp + include/msgpack/adaptor/deque_fwd.hpp include/msgpack/adaptor/detail/cpp03_define.hpp include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp include/msgpack/adaptor/detail/cpp11_define.hpp include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp + include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp include/msgpack/adaptor/fixint.hpp + include/msgpack/adaptor/fixint_fwd.hpp include/msgpack/adaptor/float.hpp + include/msgpack/adaptor/float_fwd.hpp include/msgpack/adaptor/int.hpp + include/msgpack/adaptor/int_fwd.hpp include/msgpack/adaptor/list.hpp + include/msgpack/adaptor/list_fwd.hpp include/msgpack/adaptor/map.hpp + include/msgpack/adaptor/map_fwd.hpp include/msgpack/adaptor/msgpack_tuple.hpp + include/msgpack/adaptor/msgpack_tuple_fwd.hpp include/msgpack/adaptor/nil.hpp + include/msgpack/adaptor/nil_fwd.hpp include/msgpack/adaptor/pair.hpp + include/msgpack/adaptor/pair_fwd.hpp include/msgpack/adaptor/raw.hpp + include/msgpack/adaptor/raw_fwd.hpp include/msgpack/adaptor/set.hpp + include/msgpack/adaptor/set_fwd.hpp include/msgpack/adaptor/string.hpp + include/msgpack/adaptor/string_fwd.hpp include/msgpack/adaptor/tr1/unordered_map.hpp + include/msgpack/adaptor/tr1/unordered_map_fwd.hpp include/msgpack/adaptor/tr1/unordered_set.hpp + include/msgpack/adaptor/tr1/unordered_set_fwd.hpp include/msgpack/adaptor/vector.hpp + include/msgpack/adaptor/vector_fwd.hpp + include/msgpack/adaptor/vector_char.hpp + include/msgpack/adaptor/vector_char_fwd.hpp include/msgpack/cpp_config.hpp include/msgpack/detail/cpp03_zone.hpp include/msgpack/detail/cpp11_zone.hpp include/msgpack/fbuffer.hpp include/msgpack/object.hpp - include/msgpack/object_forward.hpp + include/msgpack/object_fwd.hpp include/msgpack/pack.hpp include/msgpack/sbuffer.hpp include/msgpack/type.hpp diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index e4350202..d52f8dda 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_DEFINE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #define MSGPACK_DEFINE(...) \ template \ diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index 582762d2..a355dd77 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" namespace msgpack { @@ -31,7 +31,7 @@ namespace type { // FIXME operator!= <% GENERATION_LIMIT = 31 %> -template , typename A<%=i%> = void<%}%>> +template , typename A<%=i%><%}%>> struct tuple; template @@ -128,7 +128,7 @@ inline tuple<> make_tuple() } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> -tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>) +inline tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>) { return tuple, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>); } @@ -144,7 +144,7 @@ inline object const& operator>> ( } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple, A<%=j%><%}%>>& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -156,7 +156,7 @@ object const& operator>> ( <%}%> template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple<>&) { o.pack_array(0); @@ -164,7 +164,7 @@ const packer& operator<< ( } <%0.upto(GENERATION_LIMIT) {|i|%> template , typename A<%=j%><%}%>> -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple, A<%=j%><%}%>>& v) { o.pack_array(<%=i+1%>); diff --git a/erb/cpp03_msgpack_tuple_fwd.hpp.erb b/erb/cpp03_msgpack_tuple_fwd.hpp.erb new file mode 100644 index 00000000..99cefff0 --- /dev/null +++ b/erb/cpp03_msgpack_tuple_fwd.hpp.erb @@ -0,0 +1,125 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +// FIXME operator== +// FIXME operator!= +<% GENERATION_LIMIT = 31 %> + +template , typename A<%=i%> = void<%}%>> +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type; + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct tuple_element, A<%=k%><%}%>>, <%=j%>>; +<%}%> +<%}%> + +<%0.upto(GENERATION_LIMIT) {|i|%> +<%0.upto(i) {|j|%> +template , typename A<%=k%><%}%>> +struct const_tuple_element, A<%=k%><%}%>>, <%=j%>>; +<%}%> +<%}%> + +template <> +struct tuple<>; +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +struct tuple, A<%=j%><%}%>>; + +template , typename A<%=j%><%}%>> +typename type::tuple_element, A<%=j%><%}%>>, N>::reference get(type::tuple, A<%=j%><%}%>>& t); +template , typename A<%=j%><%}%>> +typename type::const_tuple_element, A<%=j%><%}%>>, N>::const_reference get(type::tuple, A<%=j%><%}%>> const& t); +<%}%> + +tuple<> make_tuple(); +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +tuple, A<%=j%><%}%>> make_tuple(typename tuple_type::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type>::transparent_reference a<%=j%><%}%>); +<%}%> + +} // namespace type + +object const& operator>> ( + object const& o, + type::tuple<>&); + +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +object const& operator>> ( + object const& o, + type::tuple, A<%=j%><%}%>>& v); +<%}%> + +template +const packer& operator<< ( + packer& o, + const type::tuple<>&); + +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +const packer& operator<< ( + packer& o, + const type::tuple, A<%=j%><%}%>>& v); +<%}%> + +void operator<< ( + object::with_zone& o, + const type::tuple<>&); +<%0.upto(GENERATION_LIMIT) {|i|%> +template , typename A<%=j%><%}%>> +void operator<< ( + object::with_zone& o, + const type::tuple, A<%=j%><%}%>>& v); +<%}%> + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +//std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v); +//<%0.upto(GENERATION_LIMIT) {|i|%> +//template , typename A<%=j%><%}%>> +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple, A<%=j%><%}%>>& v); +//<%}%> + +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index 69261065..ed4d263e 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -23,7 +23,7 @@ #include #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 diff --git a/include/msgpack/adaptor/bool.hpp b/include/msgpack/adaptor/bool.hpp index 1d794dd1..5194b828 100644 --- a/include/msgpack/adaptor/bool.hpp +++ b/include/msgpack/adaptor/bool.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_BOOL_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { @@ -55,4 +55,4 @@ inline void operator<< (object::with_zone& o, bool v) } // namespace msgpack -#endif /* msgpack/type/bool.hpp */ +#endif // MSGPACK_TYPE_BOOL_HPP diff --git a/include/msgpack/adaptor/bool_fwd.hpp b/include/msgpack/adaptor/bool_fwd.hpp new file mode 100644 index 00000000..aecde517 --- /dev/null +++ b/include/msgpack/adaptor/bool_fwd.hpp @@ -0,0 +1,39 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_BOOL_FWD_HPP +#define MSGPACK_TYPE_BOOL_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, bool& v); +template +packer& operator<< (packer& o, const bool& v); +void operator<< (object& o, bool v); +void operator<< (object::with_zone& o, bool v); + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_BOOL_FWD_HPP diff --git a/include/msgpack/adaptor/char_ptr.hpp b/include/msgpack/adaptor/char_ptr.hpp index cf013b34..c1071462 100644 --- a/include/msgpack/adaptor/char_ptr.hpp +++ b/include/msgpack/adaptor/char_ptr.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_CHAR_PTR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/char_ptr_fwd.hpp b/include/msgpack/adaptor/char_ptr_fwd.hpp new file mode 100644 index 00000000..f6290e6a --- /dev/null +++ b/include/msgpack/adaptor/char_ptr_fwd.hpp @@ -0,0 +1,38 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_CHAR_PTR_FWD_HPP +#define MSGPACK_TYPE_CHAR_PTR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +packer& operator<< (packer& o, const char* v); +void operator<< (object::with_zone& o, const char* v); +void operator<< (object& o, const char* v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_CHAR_PTR_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp index e9e1c972..573ff2d2 100644 --- a/include/msgpack/adaptor/cpp11/array.hpp +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -20,7 +20,7 @@ #define MSGPACK_CPP11_ARRAY_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include diff --git a/include/msgpack/adaptor/cpp11/array_char.hpp b/include/msgpack/adaptor/cpp11/array_char.hpp index 34aa2761..9df71bb1 100644 --- a/include/msgpack/adaptor/cpp11/array_char.hpp +++ b/include/msgpack/adaptor/cpp11/array_char.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_ARRAY_CHAR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/cpp11/array_char_fwd.hpp b/include/msgpack/adaptor/cpp11/array_char_fwd.hpp new file mode 100644 index 00000000..5f64e522 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array_char_fwd.hpp @@ -0,0 +1,45 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP +#define MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::array& v); + +template +packer& operator<< (packer& o, const std::array& v); + +template +void operator<< (object& o, const std::array& v); + +template +void operator<< (object::with_zone& o, const std::array& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_ARRAY_CHAR_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/array_fwd.hpp b/include/msgpack/adaptor/cpp11/array_fwd.hpp new file mode 100644 index 00000000..815694b4 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/array_fwd.hpp @@ -0,0 +1,44 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_ARRAY_FWD_HPP +#define MSGPACK_CPP11_ARRAY_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::array& v); + +template +packer& operator<< (packer& o, const std::array& v); + +template +void operator<< (object::with_zone& o, const std::array& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_ARRAY_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index d2dbebb9..6f52365d 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -20,7 +20,7 @@ #define MSGPACK_CPP11_FORWARD_LIST_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include diff --git a/include/msgpack/adaptor/cpp11/forward_list_fwd.hpp b/include/msgpack/adaptor/cpp11/forward_list_fwd.hpp new file mode 100644 index 00000000..47ca34a2 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/forward_list_fwd.hpp @@ -0,0 +1,44 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifndef MSGPACK_CPP11_FORWARD_LIST_FWD_HPP +#define MSGPACK_CPP11_FORWARD_LIST_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::forward_list& v); + +template +packer& operator<< (packer& o, const std::forward_list& v); + +template +void operator<< (object::with_zone& o, const std::forward_list& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_FORWARD_LIST_FWD_HPP diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index 704d81ab..0e1a03cd 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP11_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include @@ -57,7 +57,7 @@ struct StdTuplePacker { template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const std::tuple& v) { o.pack_array(sizeof...(Args)); @@ -95,7 +95,7 @@ struct StdTupleConverter { }; template -object const& operator>> ( +inline object const& operator>> ( object const& o, std::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } diff --git a/include/msgpack/adaptor/cpp11/tuple_fwd.hpp b/include/msgpack/adaptor/cpp11/tuple_fwd.hpp new file mode 100644 index 00000000..f17ac289 --- /dev/null +++ b/include/msgpack/adaptor/cpp11/tuple_fwd.hpp @@ -0,0 +1,62 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_TUPLE_FWD_HPP +#define MSGPACK_CPP11_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +// --- Pack ( from tuple to packer stream --- +template +struct StdTuplePacker; + +template +const packer& operator<< ( + packer& o, + const std::tuple& v); + +// --- Convert from tuple to object --- + +template +struct StdTupleConverter; + +template +object const& operator>> ( + object const& o, + std::tuple& v); + +// --- Convert from tuple to object with zone --- +template +struct StdTupleToObjectWithZone; + +template +void operator<< ( + object::with_zone& o, + std::tuple const& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_TUPLE_FWD_HPP diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index 364baff3..fc0bbbf7 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_DEQUE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/deque_fwd.hpp b/include/msgpack/adaptor/deque_fwd.hpp new file mode 100644 index 00000000..81a88189 --- /dev/null +++ b/include/msgpack/adaptor/deque_fwd.hpp @@ -0,0 +1,40 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_DEQUE_FWD_HPP +#define MSGPACK_TYPE_DEQUE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::deque& v); +template +packer& operator<< (packer& o, const std::deque& v); +template +void operator<< (object::with_zone& o, const std::deque& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_DEQUE_FWD_HPP diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index d9090236..442837cb 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_DEFINE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #define MSGPACK_DEFINE(...) \ template \ diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp index 3ffd0e29..7b9b29a1 100644 --- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" namespace msgpack { @@ -31,7 +31,7 @@ namespace type { // FIXME operator!= -template +template struct tuple; template @@ -10389,193 +10389,193 @@ inline tuple<> make_tuple() } template -tuple make_tuple(typename tuple_type::transparent_reference a0) +inline tuple make_tuple(typename tuple_type::transparent_reference a0) { return tuple(a0); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1) { return tuple(a0, a1); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2) { return tuple(a0, a1, a2); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3) { return tuple(a0, a1, a2, a3); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4) { return tuple(a0, a1, a2, a3, a4); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5) { return tuple(a0, a1, a2, a3, a4, a5); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6) { return tuple(a0, a1, a2, a3, a4, a5, a6); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22) { return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30) { return 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); } template -tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31) +inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31) { return 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); } @@ -10591,7 +10591,7 @@ inline object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10602,7 +10602,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10614,7 +10614,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10627,7 +10627,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10641,7 +10641,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10656,7 +10656,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10672,7 +10672,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10689,7 +10689,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10707,7 +10707,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10726,7 +10726,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10746,7 +10746,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10767,7 +10767,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10789,7 +10789,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10812,7 +10812,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10836,7 +10836,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10861,7 +10861,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10887,7 +10887,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10914,7 +10914,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10942,7 +10942,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -10971,7 +10971,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11001,7 +11001,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11032,7 +11032,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11064,7 +11064,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11097,7 +11097,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11131,7 +11131,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11166,7 +11166,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11202,7 +11202,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11239,7 +11239,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11277,7 +11277,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11316,7 +11316,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11356,7 +11356,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11397,7 +11397,7 @@ object const& operator>> ( } template -object const& operator>> ( +inline object const& operator>> ( object const& o, type::tuple& v) { if(o.type != type::ARRAY) { throw type_error(); } @@ -11440,7 +11440,7 @@ object const& operator>> ( template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple<>&) { o.pack_array(0); @@ -11448,7 +11448,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(1); @@ -11458,7 +11458,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(2); @@ -11469,7 +11469,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(3); @@ -11481,7 +11481,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(4); @@ -11494,7 +11494,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(5); @@ -11508,7 +11508,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(6); @@ -11523,7 +11523,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(7); @@ -11539,7 +11539,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(8); @@ -11556,7 +11556,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(9); @@ -11574,7 +11574,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(10); @@ -11593,7 +11593,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(11); @@ -11613,7 +11613,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(12); @@ -11634,7 +11634,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(13); @@ -11656,7 +11656,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(14); @@ -11679,7 +11679,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(15); @@ -11703,7 +11703,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(16); @@ -11728,7 +11728,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(17); @@ -11754,7 +11754,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(18); @@ -11781,7 +11781,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(19); @@ -11809,7 +11809,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(20); @@ -11838,7 +11838,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(21); @@ -11868,7 +11868,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(22); @@ -11899,7 +11899,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(23); @@ -11931,7 +11931,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(24); @@ -11964,7 +11964,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(25); @@ -11998,7 +11998,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(26); @@ -12033,7 +12033,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(27); @@ -12069,7 +12069,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(28); @@ -12106,7 +12106,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(29); @@ -12144,7 +12144,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(30); @@ -12183,7 +12183,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(31); @@ -12223,7 +12223,7 @@ const packer& operator<< ( } template -const packer& operator<< ( +inline const packer& operator<< ( packer& o, const type::tuple& v) { o.pack_array(32); diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp new file mode 100644 index 00000000..da8a9f26 --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp @@ -0,0 +1,4341 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +// FIXME operator== +// FIXME operator!= + + +template +struct tuple; + +template +struct tuple_element; + +template +struct const_tuple_element; + +template +struct tuple_type; + + + +template +struct tuple_element, 0>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + +template +struct tuple_element, 29>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + +template +struct tuple_element, 29>; + +template +struct tuple_element, 30>; + + + +template +struct tuple_element, 0>; + +template +struct tuple_element, 1>; + +template +struct tuple_element, 2>; + +template +struct tuple_element, 3>; + +template +struct tuple_element, 4>; + +template +struct tuple_element, 5>; + +template +struct tuple_element, 6>; + +template +struct tuple_element, 7>; + +template +struct tuple_element, 8>; + +template +struct tuple_element, 9>; + +template +struct tuple_element, 10>; + +template +struct tuple_element, 11>; + +template +struct tuple_element, 12>; + +template +struct tuple_element, 13>; + +template +struct tuple_element, 14>; + +template +struct tuple_element, 15>; + +template +struct tuple_element, 16>; + +template +struct tuple_element, 17>; + +template +struct tuple_element, 18>; + +template +struct tuple_element, 19>; + +template +struct tuple_element, 20>; + +template +struct tuple_element, 21>; + +template +struct tuple_element, 22>; + +template +struct tuple_element, 23>; + +template +struct tuple_element, 24>; + +template +struct tuple_element, 25>; + +template +struct tuple_element, 26>; + +template +struct tuple_element, 27>; + +template +struct tuple_element, 28>; + +template +struct tuple_element, 29>; + +template +struct tuple_element, 30>; + +template +struct tuple_element, 31>; + + + + + +template +struct const_tuple_element, 0>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + +template +struct const_tuple_element, 29>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + +template +struct const_tuple_element, 29>; + +template +struct const_tuple_element, 30>; + + + +template +struct const_tuple_element, 0>; + +template +struct const_tuple_element, 1>; + +template +struct const_tuple_element, 2>; + +template +struct const_tuple_element, 3>; + +template +struct const_tuple_element, 4>; + +template +struct const_tuple_element, 5>; + +template +struct const_tuple_element, 6>; + +template +struct const_tuple_element, 7>; + +template +struct const_tuple_element, 8>; + +template +struct const_tuple_element, 9>; + +template +struct const_tuple_element, 10>; + +template +struct const_tuple_element, 11>; + +template +struct const_tuple_element, 12>; + +template +struct const_tuple_element, 13>; + +template +struct const_tuple_element, 14>; + +template +struct const_tuple_element, 15>; + +template +struct const_tuple_element, 16>; + +template +struct const_tuple_element, 17>; + +template +struct const_tuple_element, 18>; + +template +struct const_tuple_element, 19>; + +template +struct const_tuple_element, 20>; + +template +struct const_tuple_element, 21>; + +template +struct const_tuple_element, 22>; + +template +struct const_tuple_element, 23>; + +template +struct const_tuple_element, 24>; + +template +struct const_tuple_element, 25>; + +template +struct const_tuple_element, 26>; + +template +struct const_tuple_element, 27>; + +template +struct const_tuple_element, 28>; + +template +struct const_tuple_element, 29>; + +template +struct const_tuple_element, 30>; + +template +struct const_tuple_element, 31>; + + + +template <> +struct tuple<>; + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + +template +struct tuple; + +template +typename type::tuple_element, N>::reference get(type::tuple& t); +template +typename type::const_tuple_element, N>::const_reference get(type::tuple const& t); + + +tuple<> make_tuple(); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30); + +template +tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31); + + +} // namespace type + +object const& operator>> ( + object const& o, + type::tuple<>&); + + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +template +object const& operator>> ( + object const& o, + type::tuple& v); + + +template +const packer& operator<< ( + packer& o, + const type::tuple<>&); + + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + + +void operator<< ( + object::with_zone& o, + const type::tuple<>&); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + +template +void operator<< ( + object::with_zone& o, + const type::tuple& v); + + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + + +//std::ostream& operator<< (std::ostream& o, const msgpack::type::tuple<>& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// +//template +//std::ostream& operator<< (std::ostream& o, +// const msgpack::type::tuple& v); +// + +#endif // MSGPACK_CPP03_MSGPACK_TUPLE_FWD_HPP diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index b8a0979f..2b0b28be 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP11_DEFINE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 4f190a86..9532021d 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP11_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp new file mode 100644 index 00000000..b9f148ef --- /dev/null +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp @@ -0,0 +1,84 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + // tuple + using std::get; + using std::tuple_size; + using std::tuple_element; + using std::uses_allocator; + using std::ignore; + using std::make_tuple; + using std::tie; + using std::forward_as_tuple; + using std::swap; + + template< class... Types > + class tuple; + + template< class... Tuples > + auto tuple_cat(Tuples&&... args) -> + decltype( + std::tuple_cat(std::forward::type::base>(args)...) + ); +} // namespace type + +// --- Pack ( from tuple to packer stream --- +template +struct MsgpackTuplePacker; + +template +const packer& operator<< ( + packer& o, + const type::tuple& v); + +// --- Convert from tuple to object --- + +template +struct MsgpackTupleConverter; + +template +object const& operator>> ( + object const& o, + type::tuple& v); + +// --- Convert from tuple to object with zone --- +template +struct MsgpackTupleToObjectWithZone; + +template +void operator<< ( + object::with_zone& o, + type::tuple const& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_CPP11_MSGPACK_TUPLE_FWD_HPP diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp index ca5e6b02..83a9e95c 100644 --- a/include/msgpack/adaptor/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_FIXINT_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include "msgpack/adaptor/int.hpp" namespace msgpack { diff --git a/include/msgpack/adaptor/fixint_fwd.hpp b/include/msgpack/adaptor/fixint_fwd.hpp new file mode 100644 index 00000000..cad85ebe --- /dev/null +++ b/include/msgpack/adaptor/fixint_fwd.hpp @@ -0,0 +1,100 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_FIXINT_FWD_HPP +#define MSGPACK_TYPE_FIXINT_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + + +template +struct fix_int; + +typedef fix_int fix_uint8; +typedef fix_int fix_uint16; +typedef fix_int fix_uint32; +typedef fix_int fix_uint64; + +typedef fix_int fix_int8; +typedef fix_int fix_int16; +typedef fix_int fix_int32; +typedef fix_int fix_int64; + + +} // namespace type + + +object const& operator>> (object const& o, type::fix_int8& v); +object const& operator>> (object const& o, type::fix_int16& v); +object const& operator>> (object const& o, type::fix_int32& v); +object const& operator>> (object const& o, type::fix_int64& v); + +object const& operator>> (object const& o, type::fix_uint8& v); +object const& operator>> (object const& o, type::fix_uint16& v); +object const& operator>> (object const& o, type::fix_uint32& v); +object const& operator>> (object const& o, type::fix_uint64& v); + +template +packer& operator<< (packer& o, const type::fix_int8& v); +template +packer& operator<< (packer& o, const type::fix_int16& v); +template +packer& operator<< (packer& o, const type::fix_int32& v); +template +packer& operator<< (packer& o, const type::fix_int64& v); + +template +packer& operator<< (packer& o, const type::fix_uint8& v); +template +packer& operator<< (packer& o, const type::fix_uint16& v); +template +packer& operator<< (packer& o, const type::fix_uint32& v); +template +packer& operator<< (packer& o, const type::fix_uint64& v); + +void operator<< (object& o, type::fix_int8 v); +void operator<< (object& o, type::fix_int16 v); +void operator<< (object& o, type::fix_int32 v); +void operator<< (object& o, type::fix_int64 v); + +void operator<< (object& o, type::fix_uint8 v); +void operator<< (object& o, type::fix_uint16 v); +void operator<< (object& o, type::fix_uint32 v); +void operator<< (object& o, type::fix_uint64 v); + +void operator<< (object::with_zone& o, type::fix_int8 v); +void operator<< (object::with_zone& o, type::fix_int16 v); +void operator<< (object::with_zone& o, type::fix_int32 v); +void operator<< (object::with_zone& o, type::fix_int64 v); + +void operator<< (object::with_zone& o, type::fix_uint8 v); +void operator<< (object::with_zone& o, type::fix_uint16 v); +void operator<< (object::with_zone& o, type::fix_uint32 v); +void operator<< (object::with_zone& o, type::fix_uint64 v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_FIXINT_FWD_HPP diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp index bbace593..499cbbe0 100644 --- a/include/msgpack/adaptor/float.hpp +++ b/include/msgpack/adaptor/float.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_FLOAT_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { @@ -102,4 +102,4 @@ inline void operator<< (object::with_zone& o, double v) } // namespace msgpack -#endif /* msgpack/type/float.hpp */ +#endif // MSGPACK_TYPE_FLOAT_HPP diff --git a/include/msgpack/adaptor/float_fwd.hpp b/include/msgpack/adaptor/float_fwd.hpp new file mode 100644 index 00000000..5eb9bafb --- /dev/null +++ b/include/msgpack/adaptor/float_fwd.hpp @@ -0,0 +1,44 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_FLOAT_FWD_HPP +#define MSGPACK_TYPE_FLOAT_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, float& v); +template +packer& operator<< (packer& o, const float& v); +object const& operator>> (object const& o, double& v); +template +packer& operator<< (packer& o, const double& v); +void operator<< (object& o, float v); +void operator<< (object& o, double v); +void operator<< (object::with_zone& o, float v); +void operator<< (object::with_zone& o, double v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_FLOAT_FWD_HPP diff --git a/include/msgpack/adaptor/int.hpp b/include/msgpack/adaptor/int.hpp index 6491d274..51c0021e 100644 --- a/include/msgpack/adaptor/int.hpp +++ b/include/msgpack/adaptor/int.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_INT_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/int_fwd.hpp b/include/msgpack/adaptor/int_fwd.hpp new file mode 100644 index 00000000..682f6b8e --- /dev/null +++ b/include/msgpack/adaptor/int_fwd.hpp @@ -0,0 +1,100 @@ +// +// MessagePack for C++ forward declaration +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_INT_FWD_HPP +#define MSGPACK_TYPE_INT_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1){ + +object const& operator>> (object const& o, char& v); + +object const& operator>> (object const& o, signed char& v); +object const& operator>> (object const& o, signed short& v); +object const& operator>> (object const& o, signed int& v); +object const& operator>> (object const& o, signed long& v); +object const& operator>> (object const& o, signed long long& v); + +object const& operator>> (object const& o, unsigned char& v); +object const& operator>> (object const& o, unsigned short& v); +object const& operator>> (object const& o, unsigned int& v); +object const& operator>> (object const& o, unsigned long& v); +object const& operator>> (object const& o, unsigned long long& v); + +template +packer& operator<< (packer& o, char v); + +template +packer& operator<< (packer& o, signed char v); +template +packer& operator<< (packer& o, signed short v); +template +packer& operator<< (packer& o, signed int v); +template +packer& operator<< (packer& o, signed long v); +template +packer& operator<< (packer& o, signed long long v); + +template +packer& operator<< (packer& o, unsigned char v); +template +packer& operator<< (packer& o, unsigned short v); +template +packer& operator<< (packer& o, unsigned int v); +template +packer& operator<< (packer& o, unsigned long v); +template +packer& operator<< (packer& o, unsigned long long v); + + +void operator<< (object& o, char v); + +void operator<< (object& o, signed char v); +void operator<< (object& o, signed short v); +void operator<< (object& o, signed int v); +void operator<< (object& o, signed long v); +void operator<< (object& o, signed long long v); + +void operator<< (object& o, unsigned char v); +void operator<< (object& o, unsigned short v); +void operator<< (object& o, unsigned int v); +void operator<< (object& o, unsigned long v); +void operator<< (object& o, unsigned long long v); + +void operator<< (object::with_zone& o, char v); + +void operator<< (object::with_zone& o, signed char v); +void operator<< (object::with_zone& o, signed short v); +void operator<< (object::with_zone& o, signed int v); +void operator<< (object::with_zone& o, signed long v); +void operator<< (object::with_zone& o, const signed long long& v); + +void operator<< (object::with_zone& o, unsigned char v); +void operator<< (object::with_zone& o, unsigned short v); +void operator<< (object::with_zone& o, unsigned int v); +void operator<< (object::with_zone& o, unsigned long v); +void operator<< (object::with_zone& o, const unsigned long long& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_INT_FWD_HPP diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index b7690dd7..b185fa24 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_LIST_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { @@ -76,4 +76,4 @@ inline void operator<< (object::with_zone& o, const std::list& v) } // namespace msgpack -#endif /* msgpack/type/list.hpp */ +#endif // MSGPACK_TYPE_LIST_HPP diff --git a/include/msgpack/adaptor/list_fwd.hpp b/include/msgpack/adaptor/list_fwd.hpp new file mode 100644 index 00000000..814a21a0 --- /dev/null +++ b/include/msgpack/adaptor/list_fwd.hpp @@ -0,0 +1,40 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_LIST_FWD_HPP +#define MSGPACK_TYPE_LIST_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::list& v); +template +packer& operator<< (packer& o, const std::list& v); +template +void operator<< (object::with_zone& o, const std::list& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_LIST_FWD_HPP diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index de9f825e..16b600d8 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_MAP_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include #include #include @@ -204,4 +204,4 @@ inline void operator<< (object::with_zone& o, const std::multimap& v) } // namespace msgpack -#endif /* msgpack/type/map.hpp */ +#endif // MSGPACK_TYPE_MAP_HPP diff --git a/include/msgpack/adaptor/map_fwd.hpp b/include/msgpack/adaptor/map_fwd.hpp new file mode 100644 index 00000000..fe5cc6b0 --- /dev/null +++ b/include/msgpack/adaptor/map_fwd.hpp @@ -0,0 +1,69 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_MAP_FWD_HPP +#define MSGPACK_TYPE_MAP_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include +#include +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +template +class assoc_vector; + +namespace detail { + template + struct pair_first_less; +} // namespace detail + +} // namespace type + + +template +object const& operator>> (object const& o, type::assoc_vector& v); +template +packer& operator<< (packer& o, const type::assoc_vector& v); +template +void operator<< (object::with_zone& o, const type::assoc_vector& v); + +template +object const& operator>> (object const& o, std::map& v); +template +packer& operator<< (packer& o, const std::map& v); +template +void operator<< (object::with_zone& o, const std::map& v); + +template +object const& operator>> (object const& o, std::multimap& v); +template +packer& operator<< (packer& o, const std::multimap& v); +template +void operator<< (object::with_zone& o, const std::multimap& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_MAP_HPP diff --git a/include/msgpack/adaptor/msgpack_tuple_fwd.hpp b/include/msgpack/adaptor/msgpack_tuple_fwd.hpp new file mode 100644 index 00000000..12ea8e9b --- /dev/null +++ b/include/msgpack/adaptor/msgpack_tuple_fwd.hpp @@ -0,0 +1,29 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_MSGPACK_TUPLE_FWD_HPP +#define MSGPACK_MSGPACK_TUPLE_FWD_HPP + +#include "msgpack/cpp_config.hpp" + +#if defined(MSGPACK_USE_CPP03) +#include "detail/cpp03_msgpack_tuple_fwd.hpp" +#else // MSGPACK_USE_CPP03 +#include "detail/cpp11_msgpack_tuple_fwd.hpp" +#endif // MSGPACK_USE_CPP03 + +#endif // MSGPACK_MSGPACK_TUPLE_FWD_HPP diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp index c8f2a0c7..1889307a 100644 --- a/include/msgpack/adaptor/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_NIL_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" namespace msgpack { @@ -65,4 +65,4 @@ inline void object::as() const } // namespace msgpack -#endif /* msgpack/type/nil.hpp */ +#endif // MSGPACK_TYPE_NIL_HPP diff --git a/include/msgpack/adaptor/nil_fwd.hpp b/include/msgpack/adaptor/nil_fwd.hpp new file mode 100644 index 00000000..80d14860 --- /dev/null +++ b/include/msgpack/adaptor/nil_fwd.hpp @@ -0,0 +1,51 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_NIL_FWD_HPP +#define MSGPACK_TYPE_NIL_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +struct nil; + +} // namespace type + + +object const& operator>> (object const& o, type::nil&); + +template +packer& operator<< (packer& o, const type::nil&); + +void operator<< (object& o, type::nil); + +void operator<< (object::with_zone& o, type::nil v); + +template <> +inline void object::as() const; + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_NIL_FWD_HPP diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp index 238abb8e..9efc1892 100644 --- a/include/msgpack/adaptor/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_PAIR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { @@ -60,4 +60,4 @@ inline void operator<< (object::with_zone& o, const std::pair& v) } // namespace msgpack -#endif /* msgpack/type/pair.hpp */ +#endif // MSGPACK_TYPE_PAIR_HPP diff --git a/include/msgpack/adaptor/pair_fwd.hpp b/include/msgpack/adaptor/pair_fwd.hpp new file mode 100644 index 00000000..d6d84d39 --- /dev/null +++ b/include/msgpack/adaptor/pair_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_PAIR_FWD_HPP +#define MSGPACK_TYPE_PAIR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::pair& v); + +template +packer& operator<< (packer& o, const std::pair& v); + +template +void operator<< (object::with_zone& o, const std::pair& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_PAIR_FWD_HPP diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp index 52790519..a01a72c8 100644 --- a/include/msgpack/adaptor/raw.hpp +++ b/include/msgpack/adaptor/raw.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_RAW_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include #include @@ -95,4 +95,4 @@ inline void operator<< (object::with_zone& o, const type::raw_ref& v) } // namespace msgpack -#endif /* msgpack/type/raw.hpp */ +#endif // MSGPACK_TYPE_RAW_HPP diff --git a/include/msgpack/adaptor/raw_fwd.hpp b/include/msgpack/adaptor/raw_fwd.hpp new file mode 100644 index 00000000..26f83434 --- /dev/null +++ b/include/msgpack/adaptor/raw_fwd.hpp @@ -0,0 +1,50 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_RAW_FWD_HPP +#define MSGPACK_TYPE_RAW_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +namespace type { + +struct raw_ref; + +} // namespace type + + +object const& operator>> (object const& o, type::raw_ref& v); + +template +packer& operator<< (packer& o, const type::raw_ref& v); + +void operator<< (object& o, const type::raw_ref& v); + +void operator<< (object::with_zone& o, const type::raw_ref& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_RAW_FWD_HPP diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index a01b1618..2e154fdb 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_SET_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include @@ -122,4 +122,4 @@ inline void operator<< (object::with_zone& o, const std::multiset& v) } // namespace msgpack -#endif /* msgpack/type/set.hpp */ +#endif // MSGPACK_TYPE_SET_HPP diff --git a/include/msgpack/adaptor/set_fwd.hpp b/include/msgpack/adaptor/set_fwd.hpp new file mode 100644 index 00000000..ae5712f8 --- /dev/null +++ b/include/msgpack/adaptor/set_fwd.hpp @@ -0,0 +1,52 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_SET_FWD_HPP +#define MSGPACK_TYPE_SET_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::set& v); + +template +packer& operator<< (packer& o, const std::set& v); + +template +void operator<< (object::with_zone& o, const std::set& v); + +template +object const& operator>> (object const& o, std::multiset& v); + +template +packer& operator<< (packer& o, const std::multiset& v); + +template +void operator<< (object::with_zone& o, const std::multiset& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_SET_FWD_HPP diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp index 66068361..dd4a37a9 100644 --- a/include/msgpack/adaptor/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_STRING_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { @@ -70,4 +70,4 @@ inline void operator<< (object& o, const std::string& v) } // namespace msgpack -#endif /* msgpack/type/string.hpp */ +#endif // MSGPACK_TYPE_STRING_HPP diff --git a/include/msgpack/adaptor/string_fwd.hpp b/include/msgpack/adaptor/string_fwd.hpp new file mode 100644 index 00000000..471654e6 --- /dev/null +++ b/include/msgpack/adaptor/string_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_STRING_FWD_HPP +#define MSGPACK_TYPE_STRING_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, std::string& v); + +template +packer& operator<< (packer& o, const std::string& v); + +void operator<< (object::with_zone& o, const std::string& v); + +void operator<< (object& o, const std::string& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_STRING_FWD_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index 77399581..de24a11c 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) @@ -149,4 +149,4 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m #undef MSGPACK_STD_TR1 -#endif /* msgpack/type/map.hpp */ +#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_map_fwd.hpp b/include/msgpack/adaptor/tr1/unordered_map_fwd.hpp new file mode 100644 index 00000000..99801e96 --- /dev/null +++ b/include/msgpack/adaptor/tr1/unordered_map_fwd.hpp @@ -0,0 +1,72 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNOURDERED_MAP +#include +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNOURDERED_MAP + +#include +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_map& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_map& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v); + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multimap& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multimap& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_FWD_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index e81fe590..928556fb 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) @@ -141,4 +141,4 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m #undef MSGPACK_STD_TR1 -#endif /* msgpack/type/set.hpp */ +#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_HPP diff --git a/include/msgpack/adaptor/tr1/unordered_set_fwd.hpp b/include/msgpack/adaptor/tr1/unordered_set_fwd.hpp new file mode 100644 index 00000000..f5e9e648 --- /dev/null +++ b/include/msgpack/adaptor/tr1/unordered_set_fwd.hpp @@ -0,0 +1,71 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP +#define MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" + +#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#define MSGPACK_HAS_STD_UNOURDERED_SET +#include +#define MSGPACK_STD_TR1 std + +#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +#if __GNUC__ >= 4 + +#define MSGPACK_HAS_STD_TR1_UNOURDERED_SET + +#include +#define MSGPACK_STD_TR1 std::tr1 + +#endif // __GNUC__ >= 4 + +#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_set& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_set& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v); + +template +object const& operator>> (object const& o, MSGPACK_STD_TR1::unordered_multiset& v); + +template +packer& operator<< (packer& o, const MSGPACK_STD_TR1::unordered_multiset& v); + +template +void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#undef MSGPACK_STD_TR1 + +#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_FWD_HPP diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index 21f2f085..c004d388 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_VECTOR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { @@ -80,4 +80,4 @@ inline void operator<< (object::with_zone& o, const std::vector& v) } // namespace msgpack -#endif /* msgpack/type/vector.hpp */ +#endif // MSGPACK_TYPE_VECTOR_HPP diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp index a702f445..225c68ce 100644 --- a/include/msgpack/adaptor/vector_char.hpp +++ b/include/msgpack/adaptor/vector_char.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_VECTOR_CHAR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/vector_char_fwd.hpp b/include/msgpack/adaptor/vector_char_fwd.hpp new file mode 100644 index 00000000..0d668efd --- /dev/null +++ b/include/msgpack/adaptor/vector_char_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2014 KONDO Takatoshi +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_CHAR_FWD_HPP +#define MSGPACK_TYPE_VECTOR_CHAR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +object const& operator>> (object const& o, std::vector& v); + +template +packer& operator<< (packer& o, const std::vector& v); + +void operator<< (object& o, const std::vector& v); + +void operator<< (object::with_zone& o, const std::vector& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_VECTOR_CHAR_FWD_HPP diff --git a/include/msgpack/adaptor/vector_fwd.hpp b/include/msgpack/adaptor/vector_fwd.hpp new file mode 100644 index 00000000..1e144018 --- /dev/null +++ b/include/msgpack/adaptor/vector_fwd.hpp @@ -0,0 +1,42 @@ +// +// MessagePack for C++ static resolution routine +// +// Copyright (C) 2008-2009 FURUHASHI Sadayuki +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#ifndef MSGPACK_TYPE_VECTOR_FWD_HPP +#define MSGPACK_TYPE_VECTOR_FWD_HPP + +#include "msgpack/versioning.hpp" +#include "msgpack/object_fwd.hpp" +#include + +namespace msgpack { + +MSGPACK_API_VERSION_NAMESPACE(v1) { + +template +object const& operator>> (object const& o, std::vector& v); + +template +packer& operator<< (packer& o, const std::vector& v); + +template +void operator<< (object::with_zone& o, const std::vector& v); + +} // MSGPACK_API_VERSION_NAMESPACE(v1) + +} // namespace msgpack + +#endif // MSGPACK_TYPE_VECTOR_FWD_HPP diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index b2acd3d8..b050a998 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -23,7 +23,7 @@ #include #include "msgpack/versioning.hpp" -#include "msgpack_forward.hpp" +#include "msgpack_fwd.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index 7e22426c..4be3fca4 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -19,9 +19,36 @@ #define MSGPACK_OBJECT_HPP #include "msgpack/versioning.hpp" -#include "msgpack/object_forward.hpp" +#include "msgpack/object_fwd.hpp" #include "msgpack/pack.hpp" #include "msgpack/zone.hpp" +#include "msgpack/adaptor/int_fwd.hpp" +#include "msgpack/adaptor/bool_fwd.hpp" +#include "msgpack/adaptor/char_ptr_fwd.hpp" +#include "msgpack/adaptor/deque_fwd.hpp" +#include "msgpack/adaptor/fixint_fwd.hpp" +#include "msgpack/adaptor/float_fwd.hpp" +#include "msgpack/adaptor/int_fwd.hpp" +#include "msgpack/adaptor/list_fwd.hpp" +#include "msgpack/adaptor/map_fwd.hpp" +#include "msgpack/adaptor/msgpack_tuple_fwd.hpp" +#include "msgpack/adaptor/nil_fwd.hpp" +#include "msgpack/adaptor/pair_fwd.hpp" +#include "msgpack/adaptor/raw_fwd.hpp" +#include "msgpack/adaptor/set_fwd.hpp" +#include "msgpack/adaptor/string_fwd.hpp" +#include "msgpack/adaptor/vector_fwd.hpp" +#include "msgpack/adaptor/vector_char_fwd.hpp" +#include "msgpack/adaptor/tr1/unordered_map_fwd.hpp" +#include "msgpack/adaptor/tr1/unordered_set_fwd.hpp" + +#if !defined(MSGPACK_USE_CPP03) +#include "adaptor/cpp11/array_fwd.hpp" +#include "adaptor/cpp11/array_char_fwd.hpp" +#include "adaptor/cpp11/forward_list_fwd.hpp" +#include "adaptor/cpp11/tuple_fwd.hpp" +#endif // !defined(MSGPACK_USE_CPP03) + #include #include #include @@ -50,6 +77,18 @@ private: object const& obj; }; +inline object const& operator>> (object const& o, object& v) +{ + v = o; + return o; +} + +template +inline object const& operator>> (object const& o, T& v) +{ + v.msgpack_unpack(o.convert()); + return o; +} // obsolete template @@ -64,38 +103,15 @@ public: template void msgpack_pack(Packer& o) const { - o << static_cast(*this); + msgpack::operator<<(o, static_cast(*this)); } void msgpack_unpack(object const& o) { - o >> static_cast(*this); + msgpack::operator>>(o, static_cast(*this)); } }; - -template -template -inline packer& packer::pack(const T& v) -{ - *this << v; - return *this; -} - -inline object const& operator>> (object const& o, object& v) -{ - v = o; - return o; -} - -// convert operator -template -inline object const& operator>> (object const& o, T& v) -{ - v.msgpack_unpack(o.convert()); - return o; -} - namespace detail { template struct packer_serializer { @@ -120,6 +136,13 @@ inline void operator<< (object::with_zone& o, const T& v) v.msgpack_object(static_cast(&o), o.zone); } +template +template +inline packer& packer::pack(const T& v) +{ + msgpack::operator<<(*this, v); + return *this; +} inline bool operator==(const object& x, const object& y) { @@ -228,7 +251,7 @@ inline object::implicit_type object::convert() const template inline void object::convert(T& v) const { - *this >> v; + msgpack::operator>>(*this, v); } template @@ -254,7 +277,7 @@ inline object::object() template inline object::object(const T& v) { - *this << v; + msgpack::operator<<(*this, v); } template @@ -268,7 +291,7 @@ template object::object(const T& v, zone& z) { with_zone oz(z); - oz << v; + msgpack::operator<<(oz, v); type = oz.type; via = oz.via; } @@ -277,7 +300,7 @@ template object::object(const T& v, zone* z) { with_zone oz(*z); - oz << v; + msgpack::operator<<(oz, v); type = oz.type; via = oz.via; } @@ -327,7 +350,7 @@ inline void pack_copy(packer& o, T v) template -packer& operator<< (packer& o, const object& v) +inline packer& operator<< (packer& o, const object& v) { switch(v.type) { case type::NIL: @@ -374,7 +397,7 @@ packer& operator<< (packer& o, const object& v) for(object* p(v.via.array.ptr), * const pend(v.via.array.ptr + v.via.array.size); p < pend; ++p) { - o << *p; + msgpack::operator<<(o, *p); } return o; @@ -383,8 +406,8 @@ packer& operator<< (packer& o, const object& v) for(object_kv* p(v.via.map.ptr), * const pend(v.via.map.ptr + v.via.map.size); p < pend; ++p) { - o << p->key; - o << p->val; + msgpack::operator<<(o, p->key); + msgpack::operator<<(o, p->val); } return o; diff --git a/include/msgpack/object_forward.hpp b/include/msgpack/object_fwd.hpp similarity index 83% rename from include/msgpack/object_forward.hpp rename to include/msgpack/object_fwd.hpp index cad24f45..e7a04c78 100644 --- a/include/msgpack/object_forward.hpp +++ b/include/msgpack/object_fwd.hpp @@ -16,8 +16,8 @@ // limitations under the License. // -#ifndef MSGPACK_OBJECT_FORWARD_HPP -#define MSGPACK_OBJECT_FORWARD_HPP +#ifndef MSGPACK_OBJECT_FWD_HPP +#define MSGPACK_OBJECT_FWD_HPP #include "msgpack/versioning.hpp" #include "msgpack/zone.hpp" @@ -137,8 +137,29 @@ struct object_kv { object val; }; +object const& operator>> (object const& o, object& v); + +template +object const& operator>> (object const& o, T& v); + +template +void operator<< (object::with_zone& o, const T& v); + + +template +class packer; + +template +packer& operator<< (packer& o, const object& v); + +template +packer& operator<< (packer& o, const T& v); + +template +void operator<< (object::with_zone& o, const T& v); + } // MSGPACK_API_VERSION_NAMESPACE(v1) } // namespace msgpack -#endif // MSGPACK_OBJECT_FORWARD_HPP +#endif // MSGPACK_OBJECT_FWD_HPP diff --git a/include/msgpack_forward.hpp b/include/msgpack_fwd.hpp similarity index 86% rename from include/msgpack_forward.hpp rename to include/msgpack_fwd.hpp index 90963fe6..91921dbb 100644 --- a/include/msgpack_forward.hpp +++ b/include/msgpack_fwd.hpp @@ -15,12 +15,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef MSGPACK_FORWARD_HPP -#define MSGPACK_FORWARD_HPP +#ifndef MSGPACK_FWD_HPP +#define MSGPACK_FWD_HPP #include "msgpack/versioning.hpp" #include "msgpack/zone.hpp" -#include "msgpack/object_forward.hpp" +#include "msgpack/object_fwd.hpp" #include "msgpack/pack.hpp" -#endif // MSGPACK_FORWARD_HPP +#endif // MSGPACK_FWD_HPP diff --git a/preprocess b/preprocess index 5efab359..e25eff3f 100755 --- a/preprocess +++ b/preprocess @@ -13,5 +13,6 @@ preprocess() { } preprocess erb/cpp03_msgpack_tuple.hpp include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +preprocess erb/cpp03_msgpack_tuple_fwd.hpp include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp preprocess erb/cpp03_define.hpp include/msgpack/adaptor/detail/cpp03_define.hpp preprocess erb/cpp03_zone.hpp include/msgpack/detail/cpp03_zone.hpp diff --git a/src/Makefile.am b/src/Makefile.am index df0a872c..2c1ba1d7 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -53,39 +53,64 @@ nobase_include_HEADERS = \ if ENABLE_CXX nobase_include_HEADERS += \ ../include/msgpack.hpp \ - ../include/msgpack_forward.hpp \ + ../include/msgpack_fwd.hpp \ ../include/msgpack/adaptor/bool.hpp \ + ../include/msgpack/adaptor/bool_fwd.hpp \ ../include/msgpack/adaptor/char_ptr.hpp \ + ../include/msgpack/adaptor/char_ptr_fwd.hpp \ ../include/msgpack/adaptor/cpp11/array.hpp \ + ../include/msgpack/adaptor/cpp11/array_fwd.hpp \ ../include/msgpack/adaptor/cpp11/array_char.hpp \ + ../include/msgpack/adaptor/cpp11/array_char_fwd.hpp \ ../include/msgpack/adaptor/cpp11/forward_list.hpp \ + ../include/msgpack/adaptor/cpp11/forward_list_fwd.hpp \ ../include/msgpack/adaptor/cpp11/tuple.hpp \ + ../include/msgpack/adaptor/cpp11/tuple_fwd.hpp \ ../include/msgpack/adaptor/define.hpp \ ../include/msgpack/adaptor/deque.hpp \ + ../include/msgpack/adaptor/deque_fwd.hpp \ ../include/msgpack/adaptor/detail/cpp03_define.hpp \ ../include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp \ + ../include/msgpack/adaptor/detail/cpp03_msgpack_tuple_fwd.hpp \ ../include/msgpack/adaptor/detail/cpp11_define.hpp \ ../include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp \ + ../include/msgpack/adaptor/detail/cpp11_msgpack_tuple_fwd.hpp \ ../include/msgpack/adaptor/fixint.hpp \ + ../include/msgpack/adaptor/fixint_fwd.hpp \ ../include/msgpack/adaptor/float.hpp \ + ../include/msgpack/adaptor/float_fwd.hpp \ ../include/msgpack/adaptor/int.hpp \ + ../include/msgpack/adaptor/int_fwd.hpp \ ../include/msgpack/adaptor/list.hpp \ + ../include/msgpack/adaptor/list_fwd.hpp \ ../include/msgpack/adaptor/map.hpp \ + ../include/msgpack/adaptor/map_fwd.hpp \ ../include/msgpack/adaptor/msgpack_tuple.hpp \ + ../include/msgpack/adaptor/msgpack_tuple_fwd.hpp \ ../include/msgpack/adaptor/nil.hpp \ + ../include/msgpack/adaptor/nil_fwd.hpp \ ../include/msgpack/adaptor/pair.hpp \ + ../include/msgpack/adaptor/pair_fwd.hpp \ ../include/msgpack/adaptor/raw.hpp \ + ../include/msgpack/adaptor/raw_fwd.hpp \ ../include/msgpack/adaptor/set.hpp \ + ../include/msgpack/adaptor/set_fwd.hpp \ ../include/msgpack/adaptor/string.hpp \ + ../include/msgpack/adaptor/string_fwd.hpp \ ../include/msgpack/adaptor/tr1/unordered_map.hpp \ + ../include/msgpack/adaptor/tr1/unordered_map_fwd.hpp \ ../include/msgpack/adaptor/tr1/unordered_set.hpp \ + ../include/msgpack/adaptor/tr1/unordered_set_fwd.hpp \ ../include/msgpack/adaptor/vector.hpp \ + ../include/msgpack/adaptor/vector_fwd.hpp \ + ../include/msgpack/adaptor/vector_char.hpp \ + ../include/msgpack/adaptor/vector_char_fwd.hpp \ ../include/msgpack/cpp_config.hpp \ ../include/msgpack/detail/cpp03_zone.hpp \ ../include/msgpack/detail/cpp11_zone.hpp \ ../include/msgpack/fbuffer.hpp \ ../include/msgpack/object.hpp \ - ../include/msgpack/object_forward.hpp \ + ../include/msgpack/object_fwd.hpp \ ../include/msgpack/pack.hpp \ ../include/msgpack/sbuffer.hpp \ ../include/msgpack/type.hpp \ From ca12e6d39d5d8659c03727f72fc34f2455bd206b Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 16 Oct 2014 14:06:57 +0900 Subject: [PATCH 149/153] Added packer_serializer class template declaration to object_fwd.hpp --- include/msgpack/object_fwd.hpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/msgpack/object_fwd.hpp b/include/msgpack/object_fwd.hpp index e7a04c78..a8ae4422 100644 --- a/include/msgpack/object_fwd.hpp +++ b/include/msgpack/object_fwd.hpp @@ -137,6 +137,11 @@ struct object_kv { object val; }; +namespace detail { +template +struct packer_serializer; +} // namespace detail + object const& operator>> (object const& o, object& v); template From fc65bc06825d0e6b6ee99de6bd0f0c5b686abad4 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Thu, 16 Oct 2014 14:07:53 +0900 Subject: [PATCH 150/153] Replaced tuple with std::tuple. Added include file int_fwd.hpp for MSGPACK_ADD_ENUM. --- include/msgpack/adaptor/detail/cpp11_define.hpp | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index 2b0b28be..1953d4b4 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -21,7 +21,11 @@ #include "msgpack/versioning.hpp" #include "msgpack_fwd.hpp" +// for MSGPACK_ADD_ENUM +#include "msgpack/adaptor/int_fwd.hpp" + #include +#include #define MSGPACK_DEFINE(...) \ template \ @@ -110,7 +114,7 @@ struct define_imp { template struct define { typedef define value_type; - typedef tuple tuple_type; + typedef std::tuple tuple_type; define(Args&... args) : a(args...) {} template @@ -118,13 +122,13 @@ struct define { { pk.pack_array(sizeof...(Args)); - define_imp, sizeof...(Args)>::pack(pk, a); + define_imp, sizeof...(Args)>::pack(pk, a); } void msgpack_unpack(msgpack::object const& o) { if(o.type != type::ARRAY) { throw type_error(); } - define_imp, sizeof...(Args)>::unpack(o, a); + define_imp, sizeof...(Args)>::unpack(o, a); } void msgpack_object(msgpack::object* o, msgpack::zone& z) const { @@ -132,16 +136,16 @@ struct define { o->via.array.ptr = static_cast(z.allocate_align(sizeof(object)*sizeof...(Args))); o->via.array.size = sizeof...(Args); - define_imp, sizeof...(Args)>::object(o, z, a); + define_imp, sizeof...(Args)>::object(o, z, a); } - tuple a; + std::tuple a; }; template <> struct define<> { typedef define<> value_type; - typedef tuple<> tuple_type; + typedef std::tuple<> tuple_type; template void msgpack_pack(Packer& pk) const { From b5e66150e98165c711f60d626c1621a4327a1ffa Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 19 Oct 2014 21:18:30 +0900 Subject: [PATCH 151/153] Minimized header files dependency. Added help comments for typical compile error. --- erb/cpp03_define.hpp.erb | 3 +- erb/cpp03_msgpack_tuple.hpp.erb | 2 +- erb/cpp03_zone.hpp.erb | 1 - include/msgpack/adaptor/bool.hpp | 2 +- include/msgpack/adaptor/char_ptr.hpp | 2 +- include/msgpack/adaptor/cpp11/array.hpp | 2 +- .../msgpack/adaptor/cpp11/forward_list.hpp | 2 +- include/msgpack/adaptor/cpp11/tuple.hpp | 2 +- include/msgpack/adaptor/deque.hpp | 2 +- .../msgpack/adaptor/detail/cpp03_define.hpp | 3 +- .../adaptor/detail/cpp03_msgpack_tuple.hpp | 2 +- .../msgpack/adaptor/detail/cpp11_define.hpp | 2 +- .../adaptor/detail/cpp11_msgpack_tuple.hpp | 2 +- include/msgpack/adaptor/fixint.hpp | 2 +- include/msgpack/adaptor/float.hpp | 2 +- include/msgpack/adaptor/list.hpp | 2 +- include/msgpack/adaptor/map.hpp | 2 +- include/msgpack/adaptor/nil.hpp | 2 +- include/msgpack/adaptor/pair.hpp | 2 +- include/msgpack/adaptor/raw.hpp | 2 +- include/msgpack/adaptor/set.hpp | 2 +- include/msgpack/adaptor/string.hpp | 2 +- include/msgpack/adaptor/tr1/unordered_map.hpp | 2 +- include/msgpack/adaptor/tr1/unordered_set.hpp | 2 +- include/msgpack/adaptor/vector.hpp | 2 +- include/msgpack/adaptor/vector_char.hpp | 2 +- include/msgpack/detail/cpp03_zone.hpp | 1 - include/msgpack/object.hpp | 66 +++++++++++++++++++ include/msgpack_fwd.hpp | 1 + 29 files changed, 94 insertions(+), 27 deletions(-) diff --git a/erb/cpp03_define.hpp.erb b/erb/cpp03_define.hpp.erb index d52f8dda..45a72f93 100644 --- a/erb/cpp03_define.hpp.erb +++ b/erb/cpp03_define.hpp.erb @@ -19,7 +19,8 @@ #define MSGPACK_CPP03_DEFINE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/adaptor/msgpack_tuple_fwd.hpp" +#include "msgpack/object_fwd.hpp" #define MSGPACK_DEFINE(...) \ template \ diff --git a/erb/cpp03_msgpack_tuple.hpp.erb b/erb/cpp03_msgpack_tuple.hpp.erb index a355dd77..9f3534a8 100644 --- a/erb/cpp03_msgpack_tuple.hpp.erb +++ b/erb/cpp03_msgpack_tuple.hpp.erb @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/erb/cpp03_zone.hpp.erb b/erb/cpp03_zone.hpp.erb index ed4d263e..9b16bb65 100644 --- a/erb/cpp03_zone.hpp.erb +++ b/erb/cpp03_zone.hpp.erb @@ -23,7 +23,6 @@ #include #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 diff --git a/include/msgpack/adaptor/bool.hpp b/include/msgpack/adaptor/bool.hpp index 5194b828..df7e7ac7 100644 --- a/include/msgpack/adaptor/bool.hpp +++ b/include/msgpack/adaptor/bool.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_BOOL_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/char_ptr.hpp b/include/msgpack/adaptor/char_ptr.hpp index c1071462..dca1acff 100644 --- a/include/msgpack/adaptor/char_ptr.hpp +++ b/include/msgpack/adaptor/char_ptr.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_CHAR_PTR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/cpp11/array.hpp b/include/msgpack/adaptor/cpp11/array.hpp index 573ff2d2..6c932adf 100644 --- a/include/msgpack/adaptor/cpp11/array.hpp +++ b/include/msgpack/adaptor/cpp11/array.hpp @@ -20,7 +20,7 @@ #define MSGPACK_CPP11_ARRAY_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include diff --git a/include/msgpack/adaptor/cpp11/forward_list.hpp b/include/msgpack/adaptor/cpp11/forward_list.hpp index 6f52365d..dd78afd6 100644 --- a/include/msgpack/adaptor/cpp11/forward_list.hpp +++ b/include/msgpack/adaptor/cpp11/forward_list.hpp @@ -20,7 +20,7 @@ #define MSGPACK_CPP11_FORWARD_LIST_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include diff --git a/include/msgpack/adaptor/cpp11/tuple.hpp b/include/msgpack/adaptor/cpp11/tuple.hpp index 0e1a03cd..b917360a 100644 --- a/include/msgpack/adaptor/cpp11/tuple.hpp +++ b/include/msgpack/adaptor/cpp11/tuple.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP11_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include diff --git a/include/msgpack/adaptor/deque.hpp b/include/msgpack/adaptor/deque.hpp index fc0bbbf7..94bac923 100644 --- a/include/msgpack/adaptor/deque.hpp +++ b/include/msgpack/adaptor/deque.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_DEQUE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/detail/cpp03_define.hpp b/include/msgpack/adaptor/detail/cpp03_define.hpp index 442837cb..3673da88 100644 --- a/include/msgpack/adaptor/detail/cpp03_define.hpp +++ b/include/msgpack/adaptor/detail/cpp03_define.hpp @@ -19,7 +19,8 @@ #define MSGPACK_CPP03_DEFINE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/adaptor/msgpack_tuple_fwd.hpp" +#include "msgpack/object_fwd.hpp" #define MSGPACK_DEFINE(...) \ template \ diff --git a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp index 7b9b29a1..70346189 100644 --- a/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP03_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object.hpp" namespace msgpack { diff --git a/include/msgpack/adaptor/detail/cpp11_define.hpp b/include/msgpack/adaptor/detail/cpp11_define.hpp index 1953d4b4..6e29b4ad 100644 --- a/include/msgpack/adaptor/detail/cpp11_define.hpp +++ b/include/msgpack/adaptor/detail/cpp11_define.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP11_DEFINE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" // for MSGPACK_ADD_ENUM #include "msgpack/adaptor/int_fwd.hpp" diff --git a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp index 9532021d..3b532d87 100644 --- a/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ b/include/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp @@ -19,7 +19,7 @@ #define MSGPACK_CPP11_MSGPACK_TUPLE_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include diff --git a/include/msgpack/adaptor/fixint.hpp b/include/msgpack/adaptor/fixint.hpp index 83a9e95c..eb7f7a8a 100644 --- a/include/msgpack/adaptor/fixint.hpp +++ b/include/msgpack/adaptor/fixint.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_FIXINT_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include "msgpack/adaptor/int.hpp" namespace msgpack { diff --git a/include/msgpack/adaptor/float.hpp b/include/msgpack/adaptor/float.hpp index 499cbbe0..8191db91 100644 --- a/include/msgpack/adaptor/float.hpp +++ b/include/msgpack/adaptor/float.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_FLOAT_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/list.hpp b/include/msgpack/adaptor/list.hpp index b185fa24..321f531b 100644 --- a/include/msgpack/adaptor/list.hpp +++ b/include/msgpack/adaptor/list.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_LIST_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/map.hpp b/include/msgpack/adaptor/map.hpp index 16b600d8..c42148e4 100644 --- a/include/msgpack/adaptor/map.hpp +++ b/include/msgpack/adaptor/map.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_MAP_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include #include #include diff --git a/include/msgpack/adaptor/nil.hpp b/include/msgpack/adaptor/nil.hpp index 1889307a..4b092e28 100644 --- a/include/msgpack/adaptor/nil.hpp +++ b/include/msgpack/adaptor/nil.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_NIL_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" namespace msgpack { diff --git a/include/msgpack/adaptor/pair.hpp b/include/msgpack/adaptor/pair.hpp index 9efc1892..27b88fae 100644 --- a/include/msgpack/adaptor/pair.hpp +++ b/include/msgpack/adaptor/pair.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_PAIR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/raw.hpp b/include/msgpack/adaptor/raw.hpp index a01a72c8..590b5de7 100644 --- a/include/msgpack/adaptor/raw.hpp +++ b/include/msgpack/adaptor/raw.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_RAW_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include #include diff --git a/include/msgpack/adaptor/set.hpp b/include/msgpack/adaptor/set.hpp index 2e154fdb..f31169c9 100644 --- a/include/msgpack/adaptor/set.hpp +++ b/include/msgpack/adaptor/set.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_SET_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include diff --git a/include/msgpack/adaptor/string.hpp b/include/msgpack/adaptor/string.hpp index dd4a37a9..05c2867f 100644 --- a/include/msgpack/adaptor/string.hpp +++ b/include/msgpack/adaptor/string.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_STRING_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/tr1/unordered_map.hpp b/include/msgpack/adaptor/tr1/unordered_map.hpp index de24a11c..7c411cfc 100644 --- a/include/msgpack/adaptor/tr1/unordered_map.hpp +++ b/include/msgpack/adaptor/tr1/unordered_map.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/adaptor/tr1/unordered_set.hpp b/include/msgpack/adaptor/tr1/unordered_set.hpp index 928556fb..1d142e6a 100644 --- a/include/msgpack/adaptor/tr1/unordered_set.hpp +++ b/include/msgpack/adaptor/tr1/unordered_set.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) diff --git a/include/msgpack/adaptor/vector.hpp b/include/msgpack/adaptor/vector.hpp index c004d388..fe643117 100644 --- a/include/msgpack/adaptor/vector.hpp +++ b/include/msgpack/adaptor/vector.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_VECTOR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/adaptor/vector_char.hpp b/include/msgpack/adaptor/vector_char.hpp index 225c68ce..1ea6c93c 100644 --- a/include/msgpack/adaptor/vector_char.hpp +++ b/include/msgpack/adaptor/vector_char.hpp @@ -19,7 +19,7 @@ #define MSGPACK_TYPE_VECTOR_CHAR_HPP #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" +#include "msgpack/object_fwd.hpp" #include namespace msgpack { diff --git a/include/msgpack/detail/cpp03_zone.hpp b/include/msgpack/detail/cpp03_zone.hpp index b050a998..8d202232 100644 --- a/include/msgpack/detail/cpp03_zone.hpp +++ b/include/msgpack/detail/cpp03_zone.hpp @@ -23,7 +23,6 @@ #include #include "msgpack/versioning.hpp" -#include "msgpack_fwd.hpp" #ifndef MSGPACK_ZONE_CHUNK_SIZE #define MSGPACK_ZONE_CHUNK_SIZE 8192 diff --git a/include/msgpack/object.hpp b/include/msgpack/object.hpp index 4be3fca4..b6df9fa5 100644 --- a/include/msgpack/object.hpp +++ b/include/msgpack/object.hpp @@ -86,6 +86,36 @@ inline object const& operator>> (object const& o, object& v) template inline object const& operator>> (object const& o, T& v) { + // If you get a error 'class your_class has no member named 'msgpack_unpack', + // check the following: + // 1. The class your_class should have MSGPACK_DEFINE macro or + // + // 2. The class your_class should have the following operator declaration and + // definition: + // inline object const& operator>> (object const& o, std::string& v) + // + // See 3. + // + // 3. #include "msgpack.hpp" too early. + // Replace msgpack.hpp with msgpack_fwd.hpp, then, + // place operator declarations as follows: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // object const& operator>> (object const& o, std::string& v); + // } + // } + // + // then, #include "msgpack.hpp", finally place the operator definitions as follows: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // object const& operator>> (object const& o, std::string& v) { + // // converting operations here + // } + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // v.msgpack_unpack(o.convert()); return o; } @@ -116,6 +146,42 @@ namespace detail { template struct packer_serializer { static packer& pack(packer& o, const T& v) { + // If you get a error 'const class your_class has no member named 'msgpack_pack', + // check the following: + // 1. The class your_class should have MSGPACK_DEFINE macro or + // + // 2. The class your_class should have the following operator declaration and + // definition: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // template + // inline packer& operator<< (packer& o, const your_class& v) + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // + // See 3. + // + // 3. #include "msgpack.hpp" too early. + // Replace msgpack.hpp with msgpack_fwd.hpp, then, + // place operator declarations as follows: + // + // namespace msgpack { + // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) { + // template + // packer& operator<< (packer& o, const your_class& v); + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // + // then, #include "msgpack.hpp", finally place the operator definitions as follows: + // + // template + // inline packer& operator<< (packer& o, const your_class& v) { + // // packing operation + // } + // } // MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) + // } // namespace msgpack + // v.msgpack_pack(o); return o; } diff --git a/include/msgpack_fwd.hpp b/include/msgpack_fwd.hpp index 91921dbb..f42ae169 100644 --- a/include/msgpack_fwd.hpp +++ b/include/msgpack_fwd.hpp @@ -21,6 +21,7 @@ #include "msgpack/versioning.hpp" #include "msgpack/zone.hpp" #include "msgpack/object_fwd.hpp" +#include "msgpack/adaptor/define.hpp" #include "msgpack/pack.hpp" #endif // MSGPACK_FWD_HPP From 11a2a1b8ecfb3ada8eb11f9a9c87c9e3c0b2ea9c Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Tue, 21 Oct 2014 22:13:53 +0900 Subject: [PATCH 152/153] Fixed https://github.com/msgpack/msgpack-c/pull/95 on poc/0.6 branch. --- test/msgpack_basic.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/test/msgpack_basic.cpp b/test/msgpack_basic.cpp index bd0a8745..210a6c5a 100644 --- a/test/msgpack_basic.cpp +++ b/test/msgpack_basic.cpp @@ -192,10 +192,8 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer) v.push_back(1); if (numeric_limits::is_signed) v.push_back(-1); else v.push_back(2); - v.push_back(numeric_limits::min()); - v.push_back(numeric_limits::max()); for (unsigned int i = 0; i < kLoop; i++) { - v.push_back(rand()); + v.push_back(rand() % 0x7FFFFF); } for (unsigned int i = 0; i < v.size() ; i++) { msgpack::sbuffer sbuf; @@ -471,4 +469,3 @@ TEST(MSGPACK_STL, simple_buffer_cstring) EXPECT_EQ(val1, val2); } } - From f8e2766d28be61811162911c52cee9f0a9f74cf5 Mon Sep 17 00:00:00 2001 From: Takatoshi Kondo Date: Sun, 26 Oct 2014 08:45:22 +0900 Subject: [PATCH 153/153] Added a 32bit environment tests for travis-ci. --- .travis.yml | 31 ++++++++++++++++++------------- CMakeLists.txt | 13 +++++++++++++ ci/build_autotools.sh | 14 ++++++++++++-- ci/build_cmake.sh | 40 ++++++++++++++++++++++++++-------------- 4 files changed, 69 insertions(+), 29 deletions(-) diff --git a/.travis.yml b/.travis.yml index 9475e13e..78ea246e 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,25 +5,30 @@ compiler: - clang - gcc before_install: -# We need this line to have g++4.8 available in apt - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test + - sudo add-apt-repository -y ppa:h-rayflood/llvm - sudo apt-get update -qq - sudo apt-get update - sudo apt-get install valgrind - - sudo apt-get install libgtest-dev - - "cd /usr/src/gtest && sudo cmake . && sudo cmake --build . && sudo mv libg* /usr/local/lib/ ; cd -" install: - - sudo apt-get install -qq gcc-4.8 g++-4.8 -# We want to compile with g++ 4.8 when rather than the default g++ + - sudo apt-get install -qq gcc-4.8-multilib g++-4.8-multilib + - sudo apt-get install --allow-unauthenticated -qq clang-3.4 - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90 -branches: - only: - - poc/0.6 + - sudo apt-get install -y lib32gcc1 + - sudo apt-get install -y libc6-i386 + - sudo apt-get install -y lib32z1-dev + - sudo apt-get install -y lib32stdc++6 + - wget https://googletest.googlecode.com/files/gtest-1.7.0.zip + - unzip gtest-1.7.0.zip && cd gtest-1.7.0 && sudo cp -r include/gtest /usr/local/include && g++ src/gtest-all.cc -I. -Iinclude -c && g++ src/gtest_main.cc -I. -Iinclude -c && ar -rv libgtest.a gtest-all.o && ar -rv libgtest_main.a gtest_main.o && sudo mv *.a /usr/local/lib && g++ -m32 src/gtest-all.cc -I. -Iinclude -c && g++ -m32 src/gtest_main.cc -I. -Iinclude -c && ar -rv libgtest.a gtest-all.o && ar -rv libgtest_main.a gtest_main.o && sudo mkdir /usr/local/lib32 && sudo mv *.a /usr/local/lib32 && cd .. env: - - ACTION="ci/build_autotools.sh" PARAM="cpp11" - - ACTION="ci/build_autotools.sh" PARAM="cpp03" - - ACTION="ci/build_cmake.sh" PARAM="cpp11" - - ACTION="ci/build_cmake.sh" PARAM="cpp03" + - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_autotools.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" + - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_autotools.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" + - ACTION="ci/build_cmake.sh" VERSION="cpp11" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_cmake.sh" VERSION="cpp11" ARCH="32" LIBPATH="/usr/local/lib32" + - ACTION="ci/build_cmake.sh" VERSION="cpp03" ARCH="64" LIBPATH="/usr/local/lib" + - ACTION="ci/build_cmake.sh" VERSION="cpp03" ARCH="32" LIBPATH="/usr/local/lib32" script: - - git clean -xdf && ${ACTION} ${PARAM} + - git clean -xdf && CMAKE_LIBRARY_PATH=${LIBPATH} ${ACTION} ${VERSION} ${ARCH} diff --git a/CMakeLists.txt b/CMakeLists.txt index 7c2dcceb..fe18db16 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,6 +16,7 @@ SET (libdir "\${exec_prefix}/lib") SET (includedir "\${prefix}/include") OPTION (MSGPACK_CXX11 "Using c++11 compiler" OFF) +OPTION (MSGPACK_32BIT "32bit compile" OFF) IF (MSGPACK_CXX11) IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") @@ -27,6 +28,18 @@ IF (MSGPACK_CXX11) ENDIF () ENDIF () +IF (MSGPACK_32BIT) + IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}") + SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}") + SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}") + ELSEIF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + SET (CMAKE_CXX_FLAGS "-m32 ${CMAKE_CXX_FLAGS}") + SET (CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}") + SET (CMAKE_EXE_LINKER_FLAGS "-m32 ${CMAKE_EXE_LINKER_FLAGS}") + ENDIF () +ENDIF () + FIND_PACKAGE (GTest) FIND_PACKAGE (ZLIB) FIND_PACKAGE (Threads) diff --git a/ci/build_autotools.sh b/ci/build_autotools.sh index a616a0da..a5ac75fd 100755 --- a/ci/build_autotools.sh +++ b/ci/build_autotools.sh @@ -9,9 +9,19 @@ fi if [ $1 = "cpp11" ] then - ./configure CXXFLAGS="-std=c++11" + if [ $2 = "32" ] + then + ./configure CFLAGS="-m32" CXXFLAGS="-std=c++11 -m32" + else + ./configure CXXFLAGS="-std=c++11" + fi else - ./configure + if [ $2 = "32" ] + then + ./configure CFLAGS="-m32" CXXFLAGS="-m32" + else + ./configure + fi fi ret=$? diff --git a/ci/build_cmake.sh b/ci/build_cmake.sh index 4f57fe9b..d0219705 100755 --- a/ci/build_cmake.sh +++ b/ci/build_cmake.sh @@ -18,9 +18,19 @@ fi if [ $1 = "cpp11" ] then - cmake -DMSGPACK_CXX11=ON .. + if [ $2 = "32" ] + then + cmake -DMSGPACK_CXX11=ON -DMSGPACK_32BIT=ON .. + else + cmake -DMSGPACK_CXX11=ON .. + fi else - cmake .. + if [ $2 = "32" ] + then + cmake -DMSGPACK_32BIT=ON .. + else + cmake .. + fi fi ret=$? @@ -53,20 +63,22 @@ then exit $ret fi -ctest -T memcheck | tee memcheck.log - -ret=${PIPESTATUS[0]} -if [ $ret -ne 0 ] +if [ $2 != "32" ] then - exit $ret + ctest -T memcheck | tee memcheck.log + + ret=${PIPESTATUS[0]} + if [ $ret -ne 0 ] + then + exit $ret + fi + cat memcheck.log | grep "Memory Leak" > /dev/null + ret=$? + if [ $ret -eq 0 ] + then + exit 1 + fi fi -cat memcheck.log | grep "Memory Leak" > /dev/null - -ret=$? -if [ $ret -eq 0 ] -then - exit 1 -fi exit 0