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); }